Fixes.

Author: jadudm

apps/authorization/views.py

@@ -31,7 +31,7 @@ class Meta:
         fields = ('id', 'name', 'logo_uri', 'tos_uri', 'policy_uri', 'contacts')
 
     def get_contacts(self, obj):
-        print(obj)
+        # print(obj)
         application = Application.objects.get(id=obj.id)
         return application.support_email or ""
 

apps/core/management/commands/create_test_feature_switches.py

@@ -62,7 +62,7 @@ def handle(self, *args, **options):
                                 flag_obj.save()
                                 self._log("User {} added to feature flag: {}".format(u, flag))
                             except Exception as e:
-                                print(e)
+                                # print(e)
                                 self._log("Exception when adding user {} to feature flag: {}".format(u, flag))
                         except User.DoesNotExist:
                             # assuming test users exist before creating flags associated with them

apps/fhir/bluebutton/tests/test_wellknown_endpoints.py

@@ -147,11 +147,11 @@ def test_smart_configuration_missing_fields_in_v3(self):
     # is commented above for reference.
 
     @skipIf((not settings.RUN_ONLINE_TESTS), "Can't reach external sites.")
-    # This overrides the switch and sets it to true, always.
-    # We should only run the test if we have v3 enabled.
     @override_switch('v3_endpoints', active=True)
     def test_fhir_metadata_extensions_have_v3(self):
-        response = self.client.get(f'{BASEURL}/v3/fhir/metadata')
+        the_url = f'{BASEURL}/v3/fhir/metadata'
+        print(the_url)
+        response = self.client.get(the_url)
         self.assertEqual(response.status_code, 200)
         json = response.json()
         self.assertIn('v3', json['implementation']['url'])

apps/testclient/management/commands/create_test_user_and_application.py

@@ -17,188 +17,147 @@
 # Imports for quieting things during startup.
 from waffle.models import Switch
 
+from uuid import uuid4
 
-def create_group(name="BlueButton"):
 
+def create_group(name="BlueButton"):
     g, created = Group.objects.get_or_create(name=name)
     if created:
         print("%s group created" % (name))
     else:
         print("%s group pre-existing. Create skipped." % (name))
     return g
 
-
-def get_switch(name):
-    try:
-        sw = Switch.objects.get(name=name)
-        return sw.active
-    except Exception as e:
-        print(f"Could not get switch {name}: {e}")
-
-
-def set_switch(name, b):
-    # DISABLE SOME WAFFLE SWITCHES
-    # We don't want email, etc.
-    sw, _ = Switch.objects.get_or_create(name=name)
-    sw.active = b
-    sw.save()
-
 # usr would be a string if it is anything
 
 
-def create_user(group, usr):
-    u_name = "rogersf"
+def create_user(the_group):
+    username = "rogersf"
     first_name = "Fred"
     last_name = "Rogers"
-    email = "fred@landofmakebelieve.gov"
-    password = "danielthetiger"
+    email = "mrrogers@landofmakebelieve.gov"
+    password = uuid4()
     user_type = "BEN"
 
-    if usr is not None:
-        u_name = usr
-        first_name = "{}{}".format(usr, "First")
-        last_name = "{}{}".format(usr, "Last")
-        email = "{}.{}@{}".format(first_name, last_name, email)
-        user_type = "DEV"
-
-    # This violates constraints on other tables.
-    usr_q = User.objects.filter(username=u_name)
-    if usr_q.exists():
-        # Delete any ADAGs for this user, or we will run into a
-        # constraint issue at startup.
-        count = ArchivedDataAccessGrant.objects.filter(beneficiary=usr_q.first()).delete()
-        print(f"Deleted {count} ADAGs for {u_name}")
-        count = DataAccessGrant.objects.filter(beneficiary=usr_q.first()).delete()
-        print(f"Deleted {count} ADAGs for {u_name}")
-
-        User.objects.filter(username=u_name).delete()
-
-    u = None
-
-    if usr is not None:
-        try:
-            u, _ = User.objects.get_or_create(username=u_name,
-                                              first_name=first_name,
-                                              last_name=last_name,
-                                              email=email,
-                                              signals_to_disable=["post_save"])
-            u.set_unusable_password()
-        except Exception as e:
-            print(f"Did not create user: {e}")
-    else:
-        # create a sample user 'fred' for dev local that has a usable password
-        try:
-            # get_or_create returns a tuple (v, bool)
-            u, _ = User.objects.get_or_create(username=u_name,
-                                              first_name=first_name,
-                                              last_name=last_name,
-                                              email=email,
-                                              password=password,)
-
-            UserProfile.objects.create(user=u,
-                                       user_type=user_type,
-                                       create_applications=True,
-                                       password_reset_question_1='1',
-                                       password_reset_answer_1='blue',
-                                       password_reset_question_2='2',
-                                       password_reset_answer_2='Frank',
-                                       password_reset_question_3='3',
-                                       password_reset_answer_3='Bentley')
-        except Exception as e:
-            print(f"Did not create user and profile: {e}")
-
-    if u is None:
-        print(f"Error creating user; exiting.")
-    else:
-        u.groups.add(group)
-
+    # We will do this over-and-over.
+    # If we don't already exist, then create the user.
+    if User.objects.filter(username=username).exists():
+        print(f"👟 {username} already exists. Skipping test user creation.")
+        return User.objects.get(username=username)
+
+    # If the user didn't exist, it is our first time through.
+    # Create the user.
+    user_obj = User.objects.create(username=username,
+                                   first_name=first_name,
+                                   last_name=last_name,
+                                   email=email,
+                                   password=password,)
+    user_obj.set_unusable_password()
+    UserProfile.objects.create(user=user_obj,
+                               user_type=user_type,
+                               create_applications=True,
+                               password_reset_question_1='1',
+                               password_reset_answer_1='blue',
+                               password_reset_question_2='2',
+                               password_reset_answer_2='Frank',
+                               password_reset_question_3='3',
+                               password_reset_answer_3='Bentley')
+    user_obj.groups.add(the_group)
+
+    # CROSSWALK
+    # Removing any existing crosswalks for this artificial user.
+    # Why? Just in case.
     user_id_hash = "ee78989d1d9ba0b98f3cfbd52479f10c7631679c17563186f70fbef038cc9536"
     Crosswalk.objects.filter(_user_id_hash=user_id_hash).delete()
-    c, _ = Crosswalk.objects.get_or_create(user=u,
-                                           fhir_id_v2=settings.DEFAULT_SAMPLE_FHIR_ID_V2,
-                                           _user_id_hash=user_id_hash)
-    return u
+    Crosswalk.objects.get_or_create(user=user_obj,
+                                    fhir_id_v2=settings.DEFAULT_SAMPLE_FHIR_ID_V2,
+                                    _user_id_hash=user_id_hash)
+    return user_obj
+
 
+def create_application(user):
+    app_name = "TestApp"
+    if Application.objects.filter(name=app_name).exists():
+        return Application.objects.get(name=app_name)
+
+    # If the app doesn't exist, create the test app.
 
-def create_application(user, group, app, redirect):
-    app_name = "TestApp" if app is None else app
     Application.objects.filter(name=app_name).delete()
     redirect_uri = "{}{}".format(settings.HOSTNAME_URL, settings.TESTCLIENT_REDIRECT_URI)
 
-    if redirect:
-        redirect_uri = redirect
+    the_app = Application.objects.create(name=app_name,
+                                         redirect_uris=redirect_uri,
+                                         user=user,
+                                         data_access_type="THIRTEEN_MONTH",
+                                         client_type="confidential",
+                                         authorization_grant_type="authorization-code",)
 
-    if not (redirect_uri.startswith("http://") or redirect_uri.startswith("https://")):
-        redirect_uri = "https://" + redirect_uri
+    titles = ["My Medicare and supplemental coverage information.",
+              "My Medicare claim information.",
+              "My general patient and demographic information.",
+              "Profile information including name and email."
+              ]
 
-    try:
-        a = Application.objects.create(name=app_name,
-                                       redirect_uris=redirect_uri,
-                                       user=user,
-                                       data_access_type="THIRTEEN_MONTH",
-                                       client_type="confidential",
-                                       authorization_grant_type="authorization-code",)
-
-        titles = ["My Medicare and supplemental coverage information.",
-                  "My Medicare claim information.",
-                  "My general patient and demographic information.",
-                  "Profile information including name and email."
-                  ]
-
-        for t in titles:
-            c = ProtectedCapability.objects.get(title=t)
-            a.scope.add(c)
-        return a
-    except Exception as e:
-        print(f"Skipped creation of {app_name}: {e}")
+    for t in titles:
+        c = ProtectedCapability.objects.get(title=t)
+        the_app.scope.add(c)
 
+    return the_app
 
-def create_test_token(user, application):
 
+def create_test_token(the_user, the_app):
+
+    # Set expiration one day from now.
     now = timezone.now()
     expires = now + timedelta(days=1)
 
-    scopes = application.scope.all()
+    scopes = the_app.scope.all()
     scope = []
     for s in scopes:
         scope.append(s.slug)
 
-    t = AccessToken.objects.create(user=user, application=application,
+    # We have to have a tokent with token="sample-token-string", because we
+    # rely on it existing for unit tests. Which are actually integration tests.
+    if AccessToken.objects.filter(token="sample-token-string").exists():
+        t = AccessToken.objects.get(token="sample-token-string")
+        t.expires = expires
+        t.save()
+    else:
+        AccessToken.objects.create(user=the_user,
+                                   application=the_app,
+                                   # This needs to be "sample-token-string", because
+                                   # we have tests that rely on it.
                                    token="sample-token-string",
                                    expires=expires,
                                    scope=' '.join(scope),)
 
-    return t
+
+def get_switch(name):
+    try:
+        sw = Switch.objects.get(name=name)
+        return sw.active
+    except Exception as e:
+        print(f"Could not get switch {name}: {e}")
+
+
+def set_switch(name, b):
+    sw, _ = Switch.objects.get_or_create(name=name)
+    sw.active = b
+    sw.save()
 
 
 class Command(BaseCommand):
     help = 'Create a test user and application for the test client'
 
-    def add_arguments(self, parser):
-        parser.add_argument("-u", "--user", help="Name of the user to be created (unique).")
-        parser.add_argument("-a", "--app", help="Name of the application to be created (unique).")
-        parser.add_argument("-r", "--redirect", help="Redirect url of the application.")
-
     def handle(self, *args, **options):
-        usr = options.get("user", None)
-        app = options.get("app", None)
-        redirect = options["redirect"]
 
         set_switch('outreach_email', False)
 
-        g = create_group()
-        u = create_user(g, usr)
-        print(f"Created user {u}")
-        a = create_application(u, g, app, redirect)
-        t = None
-        if usr is None and app is None:
-            t = create_test_token(u, a)
-            update_grants()
-        print("Name:", a.name)
-        print("client_id:", a.client_id)
-        print("client_secret:", a.client_secret)
-        print("access_token:", t.token if t else "None")
-        print("redirect_uri:", a.redirect_uris)
+        the_group = create_group()
+        the_user = create_user(the_group)
+        the_app = create_application(the_user)
+        create_test_token(the_user, the_app)
+        update_grants()
 
         # Restore switch to whatever it was.
         set_switch('outreach_email', True)

apps/testclient/tests.py

@@ -11,6 +11,8 @@
 from apps.testclient.views import FhirDataParams, _build_pagination_uri
 from django.http import HttpRequest
 
+import os
+
 
 class TestclientHelpers(TestCase):
     def test_ormap(self):
@@ -307,15 +309,15 @@ def test_offset_math(self):
         response = self.client.get(uri)
         response_data = response.json()
         self.assertEqual(response.status_code, 200)
-        # self.assertEqual(response_data["total"], 32)
-        # 20251022 MCJ
-        # For some reason, this no longer passes when asserted equal to 7.
-        # I do not know what data we test against, if it is consistent, etc.
-        # I have updated the test to `5`, and it passes. If the data is potentially variable/not in
-        # our control, then these unit tests will always be suspect (including offsets and pagination values).
-        # This seems to have been the case 7mo ago with the "total" test, above.
-        # self.assertEqual(len(response_data["entry"]), 7)
-        self.assertEqual(len(response_data["entry"]), 5)
+
+        # Different environments have different data in them.
+        # If we are testing against sandbox, we expect fewer responses.
+
+        if os.getenv("LOCAL_TESTING_TARGET", None) in ["impl"]:
+            self.assertEqual(len(response_data["entry"]), 12)
+        else:
+            self.assertEqual(len(response_data["entry"]), 5)
+
         previous_links = [
             data["url"]
             for data in response_data["link"]
@@ -327,11 +329,20 @@ def test_offset_math(self):
         first_links = [
             data["url"] for data in response_data["link"] if data["relation"] == "first"
         ]
-        self.assertEqual(len(previous_links), 1)
-        self.assertEqual(len(next_links), 0)
-        self.assertEqual(len(first_links), 1)
-        self.assertIn("startIndex=13", previous_links[0])
-        self.assertIn("startIndex=0", first_links[0])
+
+        if os.getenv("LOCAL_TESTING_TARGET", None) in ["impl"]:
+            self.assertEqual(len(previous_links), 1)
+            self.assertEqual(len(next_links), 1)
+            self.assertEqual(len(first_links), 1)
+            self.assertIn("startIndex=13", previous_links[0])
+            self.assertIn("startIndex=0", first_links[0])
+        else:
+            self.assertEqual(len(previous_links), 1)
+            self.assertEqual(len(next_links), 0)
+            self.assertEqual(len(first_links), 1)
+            self.assertIn("startIndex=13", previous_links[0])
+            self.assertIn("startIndex=0", first_links[0])
+
         self.assertContains(response, "ExplanationOfBenefit")
 
     def _test_get_eob_negative(self, version=Versions.NOT_AN_API_VERSION):

dev-local/README.md

@@ -10,6 +10,21 @@ These tools assume you are a developer working on the project, and have access t
 
 ## TL;DR
 
+```
+make build-local
+```
+
+And then
+
+```
+make run-local bfd=test auth=live daemon=1
+```
+
+or maybe
+
+```
+make run-local bfd=sbx auth=live
+```
 
 
 ## pre-requisites