def test_process_github_dependency_no_unpackaged(self):
     global_config = BaseGlobalConfig()
     config = BaseProjectConfig(global_config)
     github = self._make_github()
     del github.repositories["CumulusCI-Test"]._contents["unpackaged/pre"]
     del github.repositories["CumulusCI-Test"]._contents["unpackaged/post"]
     config.get_github_api = mock.Mock(return_value=github)
     config.keychain = DummyKeychain()
     result = config.process_github_dependency(
         {
             "github": "https://github.com/SFDO-Tooling/CumulusCI-Test.git",
             "unmanaged": True,
         }
     )
     self.assertEqual(
         result,
         [
             {
                 u"name": "Install CumulusCI-Test-Dep 2.0",
                 u"version": "2.0",
                 u"namespace": "ccitestdep",
             },
             {
                 u"name": "Deploy CumulusCI-Test",
                 u"repo_owner": "SFDO-Tooling",
                 u"repo_name": "CumulusCI-Test",
                 u"ref": "commit_sha",
                 u"subfolder": u"src",
                 u"unmanaged": True,
                 u"namespace_inject": None,
                 u"namespace_strip": None,
                 u"namespace_tokenize": None,
             },
         ],
     )
    def test_process_github_dependency_with_tag(self):
        global_config = BaseGlobalConfig()
        config = BaseProjectConfig(global_config)
        github = self._make_github()
        github.repositories["CumulusCI-Test"]._releases = [
            DummyRelease("release/1.0", "1.0")
        ]
        config.get_github_api = mock.Mock(return_value=github)
        config.keychain = DummyKeychain()

        result = config.process_github_dependency(
            {
                "github": "https://github.com/SFDO-Tooling/CumulusCI-Test.git",
                "tag": "release/1.0",
            }
        )
        self.assertIn(
            {
                "name": "Install CumulusCI-Test 1.0",
                "namespace": "ccitest",
                "version": "1.0",
                "dependencies": [
                    {
                        "name": "Install CumulusCI-Test-Dep 2.0",
                        "namespace": "ccitestdep",
                        "version": "2.0",
                    }
                ],
            },
            result,
        )
 def test_init_sentry(self, raven_client):
     config = BaseProjectConfig(BaseGlobalConfig())
     config.keychain = mock.Mock()
     config.init_sentry()
     self.assertEqual(
         {"repo", "commit", "cci version", "branch"},
         set(raven_client.call_args[1]["tags"].keys()),
     )
    def test_run_task(self):
        with temporary_dir() as d:
            os.mkdir(".git")
            os.mkdir("src")
            meta_xml_path = os.path.join(d, "src", "test-meta.xml")
            with open(meta_xml_path, "w") as f:
                f.write(
                    """<?xml version="1.0" encoding="UTF-8"?>
<ApexClass xmlns="http://soap.sforce.com/2006/04/metadata">
    <packageVersions>
        <namespace>npsp</namespace>
        <majorNumber>1</majorNumber>
        <minorNumber>0</minorNumber>
    </packageVersions>
    <packageVersions>
        <namespace>npe01</namespace>
        <majorNumber>1</majorNumber>
        <minorNumber>0</minorNumber>
    </packageVersions>
</ApexClass>
"""
                )

            project_config = BaseProjectConfig(
                BaseGlobalConfig(), config={"noyaml": True}
            )
            project_config.get_static_dependencies = mock.Mock(
                return_value=[
                    {
                        "namespace": "npsp",
                        "version": "3.0",
                        "dependencies": [{"namespace": "npe01", "version": "1.1"}],
                    }
                ]
            )
            task_config = TaskConfig()
            task = UpdateDependencies(project_config, task_config)
            task()

            with open(meta_xml_path, "r") as f:
                result = f.read()
            self.assertEqual(
                """<?xml version="1.0" encoding="UTF-8"?>
<ApexClass xmlns="http://soap.sforce.com/2006/04/metadata">
    <packageVersions>
        <namespace>npsp</namespace>
        <majorNumber>3</majorNumber>
        <minorNumber>0</minorNumber>
    </packageVersions>
    <packageVersions>
        <namespace>npe01</namespace>
        <majorNumber>1</majorNumber>
        <minorNumber>1</minorNumber>
    </packageVersions>
</ApexClass>
""",
                result,
            )
def _make_task(task_class, task_config):
    task_config = TaskConfig(task_config)
    global_config = BaseGlobalConfig()
    project_config = BaseProjectConfig(global_config, config={"noyaml": True})
    keychain = BaseProjectKeychain(project_config, "")
    project_config.set_keychain(keychain)
    org_config = DummyOrgConfig(
        {"instance_url": "https://example.com", "access_token": "abc123"}, "test"
    )
    return task_class(project_config, task_config, org_config)
 def test_get_version_for_tag_invalid_beta(self):
     config = BaseProjectConfig(
         BaseGlobalConfig(),
         {
             "project": {
                 "git": {"prefix_beta": "beta/", "prefix_release": "release/"}
             }
         },
     )
     self.assertEqual(None, config.get_version_for_tag("beta/invalid-format"))
 def test_get_version_for_tag(self):
     config = BaseProjectConfig(
         BaseGlobalConfig(),
         {
             "project": {
                 "git": {"prefix_beta": "beta/", "prefix_release": "release/"}
             }
         },
     )
     self.assertEqual("1.0", config.get_version_for_tag("release/1.0"))
class TestSalesforceToolingTask(unittest.TestCase):
    def setUp(self):
        self.api_version = 36.0
        self.global_config = BaseGlobalConfig(
            {"project": {"package": {"api_version": self.api_version}}}
        )
        self.project_config = BaseProjectConfig(
            self.global_config, config={"noyaml": True}
        )
        self.project_config.config["project"] = {
            "package": {"api_version": self.api_version}
        }
        self.project_config.config["services"] = {
            "connectedapp": {"attributes": {"client_id": {}}}
        }
        self.keychain = BaseProjectKeychain(self.project_config, "")
        self.project_config.set_keychain(self.keychain)

        self.task_config = TaskConfig()
        self.org_config = OrgConfig(
            {"instance_url": "https://example.com", "access_token": "abc123"}, "test"
        )
        self.base_tooling_url = "{}/services/data/v{}/tooling/".format(
            self.org_config.instance_url, self.api_version
        )

    def test_get_tooling_object(self):
        task = BaseSalesforceApiTask(
            self.project_config, self.task_config, self.org_config
        )
        task._init_task()
        obj = task._get_tooling_object("TestObject")
        url = self.base_tooling_url + "sobjects/TestObject/"
        self.assertEqual(obj.base_url, url)

    def test_default_client_name(self):
        task = BaseSalesforceApiTask(
            self.project_config, self.task_config, self.org_config
        )
        task._init_task()
        self.assertIn("Sforce-Call-Options", task.sf.headers)
        self.assertIn("CumulusCI/", task.sf.headers["Sforce-Call-Options"])

    def test_connected_app_client_name(self):
        self.project_config.keychain.set_service(
            "connectedapp", ServiceConfig({"client_id": "test123"})
        )

        task = BaseSalesforceApiTask(
            self.project_config, self.task_config, self.org_config
        )
        task._init_task()
        self.assertIn("Sforce-Call-Options", task.sf.headers)
        self.assertNotIn("CumulusCI/", task.sf.headers["Sforce-Call-Options"])
        self.assertIn("test123", task.sf.headers["Sforce-Call-Options"])
    def test_process_github_dependency_cannot_find_latest(self):
        global_config = BaseGlobalConfig()
        config = BaseProjectConfig(global_config)
        config.keychain = DummyKeychain()
        github = self._make_github()
        github.repositories["CumulusCI-Test-Dep"]._releases = []
        config.get_github_api = mock.Mock(return_value=github)

        with self.assertRaises(DependencyResolutionError):
            config.process_github_dependency(
                {"github": "https://github.com/SFDO-Tooling/CumulusCI-Test-Dep.git"}
            )
 def test_get_previous_version(self):
     config = BaseProjectConfig(
         BaseGlobalConfig(),
         {
             "project": {
                 "git": {"prefix_beta": "beta/", "prefix_release": "release/"}
             }
         },
     )
     config.get_github_api = mock.Mock(return_value=self._make_github())
     result = config.get_previous_version()
     self.assertEqual("1.0", result)
 def test_get_latest_tag_beta(self):
     config = BaseProjectConfig(
         BaseGlobalConfig(),
         {
             "project": {
                 "git": {"prefix_beta": "beta/", "prefix_release": "release/"}
             }
         },
     )
     config.get_github_api = mock.Mock(return_value=self._make_github())
     result = config.get_latest_tag(beta=True)
     self.assertEqual("beta/1.0-Beta_2", result)
 def test_get_latest_tag_matching_prefix(self):
     config = BaseProjectConfig(
         BaseGlobalConfig(),
         {"project": {"git": {"prefix_beta": "beta/", "prefix_release": "rel/"}}},
     )
     github = self._make_github()
     github.repositories["CumulusCI"]._releases.append(
         DummyRelease("rel/0.9", "0.9")
     )
     config.get_github_api = mock.Mock(return_value=github)
     result = config.get_latest_tag()
     self.assertEqual("rel/0.9", result)
    def test_process_github_dependency_tag_not_found(self):
        global_config = BaseGlobalConfig()
        config = BaseProjectConfig(global_config)
        config.keychain = DummyKeychain()
        config.get_github_api = mock.Mock(return_value=self._make_github())

        with self.assertRaises(DependencyResolutionError):
            config.process_github_dependency(
                {
                    "github": "https://github.com/SFDO-Tooling/CumulusCI-Test-Dep.git",
                    "tag": "bogus",
                }
            )
 def test_pretty_dependencies(self):
     dep = {
         "namespace": "npsp",
         "version": "3",
         "boolean": False,
         "dependencies": [{"repo_name": "TestRepo", "dependencies": []}],
     }
     config = BaseProjectConfig(BaseGlobalConfig())
     result = "\n".join(config.pretty_dependencies([dep]))
     self.assertEqual(
         """  - dependencies: \n    \n      - repo_name: TestRepo\n    namespace: npsp\n    version: 3""",
         result,
     )
 def setUp(self):
     self.api_version = 42.0
     self.global_config = BaseGlobalConfig(
         {"project": {"api_version": self.api_version}}
     )
     self.task_config = TaskConfig()
     self.task_config.config["options"] = {
         "class_name": "ADDR_Seasonal_BATCH",
         "poll_interval": 1,
     }
     self.project_config = BaseProjectConfig(
         self.global_config, config={"noyaml": True}
     )
     self.project_config.config["project"] = {
         "package": {"api_version": self.api_version}
     }
     keychain = BaseProjectKeychain(self.project_config, "")
     self.project_config.set_keychain(keychain)
     self.org_config = OrgConfig(
         {
             "id": "foo/1",
             "instance_url": "https://example.com",
             "access_token": "abc123",
         },
         "test",
     )
     self.base_tooling_url = "{}/services/data/v{}/tooling/".format(
         self.org_config.instance_url, self.api_version
     )
    def setUp(self):
        self.global_config = BaseGlobalConfig()
        self.project_config = BaseProjectConfig(
            self.global_config, config={"noyaml": True}
        )

        keychain = BaseProjectKeychain(self.project_config, "")
        self.project_config.set_keychain(keychain)

        self._task_log_handler.reset()
        self.task_log = self._task_log_handler.messages
        self.base_command = "sfdx force:mdapi:deploy --wait {}".format(
            CreateConnectedApp.deploy_wait
        )
        self.label = "Test_Label"
        self.username = "******"
        self.email = "TestUser@Email"
        self.task_config = TaskConfig(
            {
                "options": {
                    "label": self.label,
                    "username": self.username,
                    "email": self.email,
                }
            }
        )
Esempio n. 17
0
    def _run_task(self):
        # Find or create Version
        if not self.dry_run:
            product = self._find_product()
            version = self._find_or_create_version(product)

        # Check out the specified tag
        repo_owner = self.project_config.repo_owner
        repo_name = self.project_config.repo_name
        gh = self.project_config.get_github_api()
        repo = gh.repository(repo_owner, repo_name)
        tag = self.options["tag"]
        commit_sha = repo.tag(repo.ref("tags/" + tag).object.sha).object.sha
        self.logger.info(
            "Downloading commit {} of {} from GitHub".format(commit_sha, repo.full_name)
        )
        zf = download_extract_github(gh, repo_owner, repo_name, ref=commit_sha)
        with temporary_dir() as project_dir:
            zf.extractall(project_dir)
            project_config = BaseProjectConfig(
                self.project_config.global_config_obj,
                repo_info={
                    "root": project_dir,
                    "owner": repo_owner,
                    "name": repo_name,
                    "url": self.project_config.repo_url,
                    "branch": tag,
                    "commit": commit_sha,
                },
            )
            project_config.set_keychain(self.project_config.keychain)

            # Create each plan
            for plan_name, plan_config in self.plan_configs.items():
                steps = self._freeze_steps(project_config, plan_config)
                self.logger.debug("Prepared steps:\n" + json.dumps(steps, indent=4))
                if not self.dry_run:
                    self._publish_plan(product, version, plan_name, plan_config, steps)

            # Update version to set is_listed=True
            if not self.dry_run:
                self._call_api(
                    "PATCH",
                    "/versions/{}".format(version["id"]),
                    json={"is_listed": True},
                )
                self.logger.info("Published Version {}".format(version["url"]))
Esempio n. 18
0
    def test_repo_commit(self, mock_class):
        mock_class.return_value = self.tempdir_home
        os.mkdir(os.path.join(self.tempdir_project, ".git"))
        self._create_git_config()

        # create valid project config file
        self._create_project_config()

        os.chdir(self.tempdir_project)
        global_config = BaseGlobalConfig()
        config = BaseProjectConfig(global_config)
        self.assertEqual(config.repo_commit, self.current_commit)
Esempio n. 19
0
    def test_process_github_dependency_with_tag(self):
        global_config = BaseGlobalConfig()
        config = BaseProjectConfig(global_config)
        config.get_github_api = DummyGithub
        config.keychain = DummyKeychain()

        result = config.process_github_dependency({
            "github": "https://github.com/SFDO-Tooling/CumulusCI-Test.git",
            "tag": "release/1.0",
        })
        self.assertIn(
            {
                "namespace": "ccitest",
                "version": "1.0",
                "dependencies": [{
                    "namespace": "ccitestdep",
                    "version": "2"
                }],
            },
            result,
        )
Esempio n. 20
0
 def test_create_scratch_org(self):
     project_config = BaseProjectConfig(self.global_config,
                                        {"orgs": {
                                            "scratch": {
                                                "dev": {}
                                            }
                                        }})
     keychain = self.keychain_class(project_config, self.key)
     keychain.set_org = mock.Mock()
     keychain.create_scratch_org("test", "dev", days=3)
     org_config = keychain.set_org.call_args[0][0]
     self.assertEqual(3, org_config.days)
Esempio n. 21
0
    def setUp(self):
        self.global_config = BaseGlobalConfig()
        self.project_config = BaseProjectConfig(
            self.global_config, config={"noyaml": True}
        )
        self.task_config = TaskConfig()

        keychain = BaseProjectKeychain(self.project_config, "")
        self.project_config.set_keychain(keychain)

        self._task_log_handler.reset()
        self.task_log = self._task_log_handler.messages
Esempio n. 22
0
    def test_repo_commit_packed_refs(self):
        config = BaseProjectConfig(BaseGlobalConfig())
        with temporary_dir() as d:
            os.system("git init")
            with open(os.path.join(d, ".git", "packed-refs"), "w") as f:
                f.write("# pack-refs with: peeled fully-peeled sorted\n")
                f.write("#\n")
                f.write(
                    "8ce67f4519190cd1ec9785105168e21b9599bc27 refs/remotes/origin/master\n"
                )

            self.assertIsNotNone(config.repo_commit)
Esempio n. 23
0
    def test_repo_branch(self, mock_class):
        mock_class.return_value = self.tempdir_home
        os.mkdir(os.path.join(self.tempdir_project, ".git"))
        self._create_git_config()

        # create valid project config file
        self._create_project_config()

        with cd(self.tempdir_project):
            universal_config = UniversalConfig()
            config = BaseProjectConfig(universal_config)
            self.assertEqual(config.repo_branch, self.current_branch)
Esempio n. 24
0
    def test_sources(self, mock_robot_run):
        """Verify that sources get added to PYTHONPATH when task runs"""
        universal_config = UniversalConfig()
        project_config = BaseProjectConfig(
            universal_config,
            {
                "sources": {
                    "test1": {
                        "path": "dummy1"
                    },
                    "test2": {
                        "path": "dummy2"
                    },
                }
            },
        )
        # get_namespace returns a config. The only part of the config
        # that the code uses is the repo_root property, so we don't need
        # a full blown config.
        project_config.get_namespace = mock.Mock(
            side_effect=lambda source: mock.Mock(repo_root=project_config.
                                                 sources[source]["path"]))

        task = create_task(
            Robot,
            {
                "suites": "test",
                "sources": ["test1", "test2"]
            },
            project_config=project_config,
        )

        mock_robot_run.return_value = 0
        self.assertFalse("dummy1" in sys.path)
        self.assertFalse("dummy2" in sys.path)
        task()
        project_config.get_namespace.assert_has_calls(
            [mock.call("test1"), mock.call("test2")])
        self.assertTrue("dummy1" in sys.path)
        self.assertTrue("dummy2" in sys.path)
Esempio n. 25
0
    def test_process_github_dependency(self):
        global_config = BaseGlobalConfig()
        config = BaseProjectConfig(global_config)
        config.get_github_api = DummyGithub
        config.keychain = DummyKeychain()

        result = config.process_github_dependency({
            'github': 'https://github.com/SalesforceFoundation/CumulusCI-Test',
            'unmanaged': True,
        })
        self.assertEqual(result, [
            {
                u'headers': {u'Authorization': u'token password'},
                u'namespace_inject': None,
                u'namespace_strip': None,
                u'namespace_tokenize': None,
                u'subfolder': u'CumulusCI-Test-master/unpackaged/pre/pre',
                u'unmanaged': True,
                u'zip_url': u'https://github.com/SalesforceFoundation/CumulusCI-Test/archive/master.zip',
            },
            {u'version': '2', u'namespace': 'ccitestdep'},
            {
                u'headers': {u'Authorization': u'token password'},
                u'namespace_inject': None,
                u'namespace_strip': None,
                u'namespace_tokenize': None,
                u'subfolder': u'CumulusCI-Test-master/src',
                u'unmanaged': True,
                u'zip_url': u'https://github.com/SalesforceFoundation/CumulusCI-Test/archive/master.zip',
            },
            {
                u'headers': {u'Authorization': u'token password'},
                u'namespace_inject': 'ccitest',
                u'namespace_strip': None,
                u'namespace_tokenize': None,
                u'subfolder': u'CumulusCI-Test-master/unpackaged/post/post',
                u'unmanaged': True,
                u'zip_url': u'https://github.com/SalesforceFoundation/CumulusCI-Test/archive/master.zip',
            },
        ])
Esempio n. 26
0
    def setUp(self):
        self.global_config = BaseGlobalConfig()
        self.project_config = BaseProjectConfig(self.global_config,
                                                config={"noyaml": True})

        keychain = BaseProjectKeychain(self.project_config, "")
        self.project_config.set_keychain(keychain)

        self._task_log_handler.reset()
        self.task_log = self._task_log_handler.messages
        self.base_command = "sfdx force:mdapi:deploy --wait {}".format(
            CreateConnectedApp.deploy_wait)
        self.label = "Test_Label"
        self.username = "******"
        self.email = "TestUser@Email"
        self.task_config = TaskConfig({
            "options": {
                "label": self.label,
                "username": self.username,
                "email": self.email,
            }
        })
Esempio n. 27
0
 def setUp(self):
     self.api_version = 38.0
     self.global_config = BaseGlobalConfig(
         {'project': {'api_version': self.api_version}})
     self.task_config = TaskConfig()
     self.task_config.config['options'] = {
         'junit_output': 'results_junit.xml',
         'poll_interval': 1,
         'test_name_match': '%_TEST',
     }
     self.project_config = BaseProjectConfig(self.global_config)
     self.project_config.config['project'] = {'package': {
         'api_version': self.api_version}}
     keychain = BaseProjectKeychain(self.project_config, '')
     self.project_config.set_keychain(keychain)
     self.org_config = OrgConfig({
         'id': 'foo/1',
         'instance_url': 'example.com',
         'access_token': 'abc123',
     }, 'test')
     self.base_tooling_url = 'https://{}/services/data/v{}/tooling/'.format(
         self.org_config.instance_url, self.api_version)
 def setUp(self):
     self.api_version = 42.0
     self.global_config = BaseGlobalConfig(
         {"project": {
             "api_version": self.api_version
         }})
     self.tmpdir = tempfile.mkdtemp(dir=".")
     apex_path = os.path.join(self.tmpdir, "test.apex")
     with open(apex_path, "w") as f:
         f.write('System.debug("from file")')
     self.task_config = TaskConfig()
     self.task_config.config["options"] = {
         "path": apex_path,
         "apex": 'system.debug("Hello World!")',
         "namespaced": True,
         "param1": "StringValue",
     }
     self.project_config = BaseProjectConfig(self.global_config,
                                             config={"noyaml": True})
     self.project_config.config = {
         "project": {
             "package": {
                 "namespace": "abc",
                 "api_version": self.api_version
             }
         }
     }
     keychain = BaseProjectKeychain(self.project_config, "")
     self.project_config.set_keychain(keychain)
     self.org_config = OrgConfig(
         {
             "id": "foo/1",
             "instance_url": "https://example.com",
             "access_token": "abc123",
         },
         "test",
     )
     self.base_tooling_url = "{}/services/data/v{}/tooling/".format(
         self.org_config.instance_url, self.api_version)
Esempio n. 29
0
def _make_task(task_class, task_config):
    task_config = TaskConfig(task_config)
    global_config = BaseGlobalConfig()
    project_config = BaseProjectConfig(
        global_config,
        config={
            "noyaml": True,
            "project": {
                "package": {
                    "api_version": "46.0"
                }
            }
        },
    )
    keychain = BaseProjectKeychain(project_config, "")
    project_config.set_keychain(keychain)
    org_config = DummyOrgConfig(
        {
            "instance_url": "https://example.com",
            "access_token": "abc123"
        }, "test")
    return task_class(project_config, task_config, org_config)
Esempio n. 30
0
 def setUp(self):
     self.universal_config = UniversalConfig()
     self.project_config = BaseProjectConfig(self.universal_config,
                                             config={"noyaml": True})
     self.task_config = TaskConfig({"options": {"command": "ls"}})
     self.org_config = OrgConfig(
         {
             "access_token": "TOKEN",
             "instance_url": "https://na01.salesforce.com"
         },
         "test",
     )
     self.org_config.refresh_oauth_token = mock.Mock()
    def test_load_project_config_empty_config(self, mock_class):
        mock_class.return_value = self.tempdir_home
        os.mkdir(os.path.join(self.tempdir_project, ".git"))
        self._create_git_config()
        # create empty project config file
        filename = os.path.join(self.tempdir_project, BaseProjectConfig.config_filename)
        content = ""
        self._write_file(filename, content)

        os.chdir(self.tempdir_project)
        global_config = BaseGlobalConfig()
        config = BaseProjectConfig(global_config)
        self.assertEqual(config.config_project, {})
Esempio n. 32
0
    def setUp(self):
        self.global_config = BaseGlobalConfig()
        self.project_config = BaseProjectConfig(self.global_config,
                                                config={"noyaml": True})
        self.task_config = TaskConfig()

        self._task_log_handler.reset()
        self.task_log = self._task_log_handler.messages

        self.Popen = MockPopen()
        self.r = Replacer()
        self.r.replace("cumulusci.tasks.command.subprocess.Popen", self.Popen)
        self.addCleanup(self.r.restore)
 def setUp(self):
     self.project_config = BaseProjectConfig(BaseGlobalConfig(), get_base_config())
     self.project_config.config["project"]["package"]["namespace"] = "npsp"
     self.project_config.config["project"]["dependencies"] = [
         {"namespace": "nochangedep", "version": "1.0"},
         {"namespace": "changedep", "version": "1.1"},
     ]
     keychain = BaseProjectKeychain(self.project_config, "")
     keychain.set_service(
         "mrbelvedere",
         ServiceConfig({"base_url": "http://mrbelvedere", "api_key": "1234"}),
     )
     self.project_config.set_keychain(keychain)
     self.task_config = TaskConfig({"options": {"tag": "beta/1.0-Beta_2"}})
Esempio n. 34
0
 def test_repo_info_missing_env(self):
     env = {
         "CUMULUSCI_AUTO_DETECT": "1",
         "HEROKU_TEST_RUN_ID": "TEST1",
         "HEROKU_TEST_RUN_BRANCH": "master",
         "HEROKU_TEST_RUN_COMMIT_VERSION": "HEAD",
         "CUMULUSCI_REPO_BRANCH": "feature/test",
         "CUMULUSCI_REPO_COMMIT": "HEAD~1",
         "CUMULUSCI_REPO_ROOT": ".",
     }
     with mock.patch.dict(os.environ, env):
         with self.assertRaises(ConfigError):
             config = BaseProjectConfig(BaseGlobalConfig())
             config.repo_info
Esempio n. 35
0
 def test_run_task(self, removeXmlElement):
     with temporary_dir() as path:
         revert_path = os.path.join(os.path.dirname(path),
                                    os.path.basename(path) + "_revert")
         project_config = BaseProjectConfig(BaseGlobalConfig())
         task_config = TaskConfig(
             {"options": {
                 "path": path,
                 "revert_path": revert_path
             }})
         task = CreateUnmanagedEESrc(project_config, task_config)
         task()
         removeXmlElement.assert_called_once_with("availableFields", path,
                                                  "*.object")
Esempio n. 36
0
 def setUp(self):
     self.api_version = 42.0
     self.global_config = BaseGlobalConfig(
         {"project": {"api_version": self.api_version}}
     )
     self.task_config = TaskConfig()
     self.task_config.config["options"] = {
         "class_name": "ADDR_Seasonal_BATCH",
         "poll_interval": 1,
     }
     self.project_config = BaseProjectConfig(self.global_config)
     self.project_config.config["project"] = {
         "package": {"api_version": self.api_version}
     }
     keychain = BaseProjectKeychain(self.project_config, "")
     self.project_config.set_keychain(keychain)
     self.org_config = OrgConfig(
         {"id": "foo/1", "instance_url": "example.com", "access_token": "abc123"},
         "test",
     )
     self.base_tooling_url = "https://{}/services/data/v{}/tooling/".format(
         self.org_config.instance_url, self.api_version
     )
Esempio n. 37
0
 def test_get_package_zip(self, CreatePackageZipBuilder):
     project_config = BaseProjectConfig(
         BaseGlobalConfig(),
         {
             "project": {
                 "package": {
                     "name": "TestPackage",
                     "api_version": "43.0"
                 }
             }
         },
     )
     task = create_task(CreatePackage, project_config=project_config)
     task._get_package_zip()
     CreatePackageZipBuilder.assert_called_once()
Esempio n. 38
0
 def test_run_task(self):
     with temporary_dir() as revert_path:
         with open(os.path.join(revert_path, "file"), "w") as f:
             pass
         path = os.path.join(os.path.dirname(revert_path),
                             os.path.basename(revert_path) + "_orig")
         project_config = BaseProjectConfig(BaseGlobalConfig())
         task_config = TaskConfig(
             {"options": {
                 "path": path,
                 "revert_path": revert_path
             }})
         task = RevertUnmanagedEESrc(project_config, task_config)
         task()
         self.assertTrue(os.path.exists(os.path.join(path, "file")))
    def test_load_project_config_valid_config(self, mock_class):
        mock_class.return_value = self.tempdir_home
        os.mkdir(os.path.join(self.tempdir_project, ".git"))
        self._create_git_config()
        local_yaml = "tasks:\n    newtesttask:\n        description: test description"
        self._create_global_config_local(local_yaml)

        # create valid project config file
        self._create_project_config()

        os.chdir(self.tempdir_project)
        global_config = BaseGlobalConfig()
        config = BaseProjectConfig(global_config)
        self.assertEqual(config.project__package__name, "TestProject")
        self.assertEqual(config.project__package__namespace, "testproject")
Esempio n. 40
0
 def setUp(self):
     self.api_version = 38.0
     self.global_config = BaseGlobalConfig(
         {"project": {"api_version": self.api_version}}
     )
     self.task_config = TaskConfig()
     self.task_config.config["options"] = {
         "junit_output": "results_junit.xml",
         "poll_interval": 1,
         "test_name_match": "%_TEST",
     }
     self.project_config = BaseProjectConfig(self.global_config)
     self.project_config.config["project"] = {
         "package": {"api_version": self.api_version}
     }
     keychain = BaseProjectKeychain(self.project_config, "")
     self.project_config.set_keychain(keychain)
     self.org_config = OrgConfig(
         {"id": "foo/1", "instance_url": "example.com", "access_token": "abc123"},
         "test",
     )
     self.base_tooling_url = "https://{}/services/data/v{}/tooling/".format(
         self.org_config.instance_url, self.api_version
     )
Esempio n. 41
0
 def setUp(self):
     self.project_config = BaseProjectConfig(BaseGlobalConfig(),
                                             get_base_config())
     self.project_config.config["project"]["package"]["namespace"] = "npsp"
     self.project_config.config["project"]["dependencies"] = [
         {
             "namespace": "nochangedep",
             "version": "1.0"
         },
         {
             "namespace": "changedep",
             "version": "1.1"
         },
     ]
     keychain = BaseProjectKeychain(self.project_config, "")
     keychain.set_service(
         "mrbelvedere",
         ServiceConfig({
             "base_url": "http://mrbelvedere",
             "api_key": "1234"
         }),
     )
     self.project_config.set_keychain(keychain)
     self.task_config = TaskConfig({"options": {"tag": "beta/1.0-Beta_2"}})
Esempio n. 42
0
    def setUp(self):
        self.api_version = 36.0
        self.universal_config = UniversalConfig(
            {"project": {"package": {"api_version": self.api_version}}}
        )
        self.project_config = BaseProjectConfig(
            self.universal_config, config={"noyaml": True}
        )
        self.project_config.config["project"] = {
            "package": {"api_version": self.api_version}
        }
        self.project_config.config["services"] = {
            "connectedapp": {"attributes": {"client_id": {}}}
        }
        self.keychain = BaseProjectKeychain(self.project_config, "")
        self.project_config.set_keychain(self.keychain)

        self.task_config = TaskConfig()
        self.org_config = OrgConfig(
            {"instance_url": "https://example.com", "access_token": "abc123"}, "test"
        )
        self.base_tooling_url = "{}/services/data/v{}/tooling/".format(
            self.org_config.instance_url, self.api_version
        )
Esempio n. 43
0
 def setUp(self):
     self.global_config = BaseGlobalConfig()
     self.project_config = BaseProjectConfig(self.global_config,
                                             config={"no_yaml": True})
     self.project_config.config["services"] = {
         "connected_app": {
             "attributes": {
                 "test": {
                     "required": True
                 }
             }
         },
         "github": {
             "attributes": {
                 "name": {
                     "required": True
                 },
                 "password": {}
             }
         },
         "mrbelvedere": {
             "attributes": {
                 "mr": {
                     "required": True
                 }
             }
         },
         "not_configured": {
             "attributes": {
                 "foo": {
                     "required": True
                 }
             }
         },
     }
     self.project_config.project__name = "TestProject"
     self.services = {
         "connected_app": ServiceConfig({"test": "value"}),
         "github": ServiceConfig({"name": "hub"}),
         "mrbelvedere": ServiceConfig({"mr": "belvedere"}),
     }
     self.org_config = OrgConfig({"foo": "bar"}, "test")
     self.scratch_org_config = ScratchOrgConfig(
         {
             "foo": "bar",
             "scratch": True
         }, "test_scratch")
     self.key = "0123456789123456"
Esempio n. 44
0
    def setUp(self):
        self.global_config = BaseGlobalConfig()
        self.project_config = BaseProjectConfig(self.global_config,
                                                config={"noyaml": True})
        self.project_config.config["services"] = {
            "connected_app": {
                "attributes": {
                    "test": {
                        "required": True
                    }
                }
            },
            "github": {
                "attributes": {
                    "git": {
                        "required": True
                    },
                    "password": {}
                }
            },
            "not_configured": {
                "attributes": {
                    "foo": {
                        "required": True
                    }
                }
            },
        }
        self.project_config.project__name = "TestProject"
        self.project_name = "TestProject"
        self.org_config = OrgConfig({"foo": "bar"}, "test")
        self.scratch_org_config = ScratchOrgConfig(
            {
                "foo": "bar",
                "scratch": True
            }, "test_scratch")
        self.services = {
            "connected_app": ServiceConfig({"test": "value"}),
            "github": ServiceConfig({"git": "hub"}),
        }
        self.key = "0123456789123456"

        self._mk_temp_home()
        self._expanduser_patch = mock.patch("os.path.expanduser",
                                            return_value=self.tempdir_home)
        self._expanduser_patch.__enter__()
        self._mk_temp_project()
        os.chdir(self.tempdir_project)
Esempio n. 45
0
 def setUp(self):
     self.global_config = BaseGlobalConfig()
     self.project_config = BaseProjectConfig(self.global_config)
     self.project_config.config['services'] = {
         'connected_app': {
             'attributes': {
                 'test': {
                     'required': True
                 }
             }
         },
         'github': {
             'attributes': {
                 'git': {
                     'required': True
                 },
                 'password': {}
             }
         },
         'mrbelvedere': {
             'attributes': {
                 'mr': {
                     'required': True
                 }
             }
         },
         'not_configured': {
             'attributes': {
                 'foo': {
                     'required': True
                 }
             }
         },
     }
     self.project_config.project__name = 'TestProject'
     self.project_name = 'TestProject'
     self.org_config = OrgConfig({'foo': 'bar'}, 'test')
     self.scratch_org_config = ScratchOrgConfig(
         {
             'foo': 'bar',
             'scratch': True
         }, 'test_scratch')
     self.services = {
         'connected_app': ServiceConfig({'test': 'value'}),
         'github': ServiceConfig({'git': 'hub'}),
         'mrbelvedere': ServiceConfig({'mr': 'belvedere'}),
     }
     self.key = '0123456789123456'
    def test_load_additional_yaml(self, mock_class):
        mock_class.return_value = self.tempdir_home
        os.mkdir(os.path.join(self.tempdir_project, ".git"))
        self._create_git_config()

        # create valid project config file
        self._create_project_config()

        # create local project config file
        content = "project:\n" + "    package:\n" + "        api_version: 10\n"

        os.chdir(self.tempdir_project)
        global_config = BaseGlobalConfig()
        config = BaseProjectConfig(global_config, additional_yaml=content)
        self.assertNotEqual(config.config_additional_yaml, {})
        self.assertEqual(config.project__package__api_version, 10)
Esempio n. 47
0
    def test_task_run_not_found(self):
        config = mock.Mock()
        config.get_org.return_value = (None, None)
        config.project_config = BaseProjectConfig(BaseGlobalConfig(), config={})

        with self.assertRaises(click.UsageError):
            run_click_command(
                cci.task_run,
                config=config,
                task_name="test",
                org=None,
                o=[("color", "blue")],
                debug=False,
                debug_before=False,
                debug_after=False,
                no_prompt=True,
            )
Esempio n. 48
0
    def test_load_project_config_local(self, mock_class):
        mock_class.return_value = self.tempdir_home
        os.mkdir(os.path.join(self.tempdir_project, ".git"))
        self._create_git_config()

        # create valid project config file
        self._create_project_config()

        # create local project config file
        content = "project:\n" + "    package:\n" + "        api_version: 45.0\n"
        self._create_project_config_local(content)

        with cd(self.tempdir_project):
            universal_config = UniversalConfig()
            config = BaseProjectConfig(universal_config)
            self.assertNotEqual(config.config_project_local, {})
            self.assertEqual(config.project__package__api_version, 45.0)
Esempio n. 49
0
 def test_get_package_zip(self):
     project_config = BaseProjectConfig(
         UniversalConfig(),
         {
             "project": {
                 "package": {
                     "name": "TestPackage",
                     "api_version": "43.0"
                 }
             }
         },
     )
     task = create_task(CreatePackage, project_config=project_config)
     package_zip = task._get_package_zip()
     zf = zipfile.ZipFile(io.BytesIO(base64.b64decode(package_zip)), "r")
     package_xml = zf.read("package.xml")
     assert b"<fullName>TestPackage</fullName>" in package_xml
    def setUp(self):
        self.api_version = 36.0
        self.global_config = BaseGlobalConfig(
            {"project": {"package": {"api_version": self.api_version}}}
        )
        self.project_config = BaseProjectConfig(
            self.global_config, config={"noyaml": True}
        )
        self.project_config.config["project"] = {
            "package": {"api_version": self.api_version}
        }
        self.project_config.config["services"] = {
            "connectedapp": {"attributes": {"client_id": {}}}
        }
        self.keychain = BaseProjectKeychain(self.project_config, "")
        self.project_config.set_keychain(self.keychain)

        self.task_config = TaskConfig()
        self.org_config = OrgConfig(
            {"instance_url": "https://example.com", "access_token": "abc123"}, "test"
        )
        self.base_tooling_url = "{}/services/data/v{}/tooling/".format(
            self.org_config.instance_url, self.api_version
        )
Esempio n. 51
0
 def setUp(self):
     self.api_version = 38.0
     self.global_config = BaseGlobalConfig(
         {'project': {'api_version': self.api_version}})
     self.task_config = TaskConfig()
     self.task_config.config['options'] = {
         'junit_output': 'results_junit.xml',
         'poll_interval': 1,
         'test_name_match': '%_TEST',
     }
     self.project_config = BaseProjectConfig(self.global_config)
     self.project_config.config['project'] = {'package': {
         'api_version': self.api_version}}
     keychain = BaseProjectKeychain(self.project_config, '')
     app_config = ConnectedAppOAuthConfig()
     keychain.set_connected_app(app_config)
     self.project_config.set_keychain(keychain)
     self.org_config = OrgConfig({
         'id': 'foo/1',
         'instance_url': 'example.com',
         'access_token': 'abc123',
     })
     self.base_tooling_url = 'https://{}/services/data/v{}/tooling/'.format(
         self.org_config.instance_url, self.api_version)
 def setUp(self):
     self.api_version = 42.0
     self.global_config = BaseGlobalConfig(
         {"project": {"api_version": self.api_version}}
     )
     self.tmpdir = tempfile.mkdtemp(dir=".")
     apex_path = os.path.join(self.tmpdir, "test.apex")
     with open(apex_path, "w") as f:
         f.write('System.debug("from file")')
     self.task_config = TaskConfig()
     self.task_config.config["options"] = {
         "path": apex_path,
         "apex": 'system.debug("Hello World!")',
         "namespaced": True,
     }
     self.project_config = BaseProjectConfig(
         self.global_config, config={"noyaml": True}
     )
     self.project_config.config = {
         "project": {
             "package": {"namespace": "abc", "api_version": self.api_version}
         }
     }
     keychain = BaseProjectKeychain(self.project_config, "")
     self.project_config.set_keychain(keychain)
     self.org_config = OrgConfig(
         {
             "id": "foo/1",
             "instance_url": "https://example.com",
             "access_token": "abc123",
         },
         "test",
     )
     self.base_tooling_url = "{}/services/data/v{}/tooling/".format(
         self.org_config.instance_url, self.api_version
     )
 def test_repo_commit_from_repo_info(self):
     config = BaseProjectConfig(BaseGlobalConfig())
     config._repo_info = {"commit": "abcdef"}
     self.assertEqual("abcdef", config.repo_commit)
 def test_get_tag_for_version_beta(self):
     config = BaseProjectConfig(
         BaseGlobalConfig(), {"project": {"git": {"prefix_beta": "beta/"}}}
     )
     self.assertEqual("beta/1.0-Beta_1", config.get_tag_for_version("1.0 (Beta 1)"))
 def test_get_tag_for_version(self):
     config = BaseProjectConfig(
         BaseGlobalConfig(), {"project": {"git": {"prefix_release": "release/"}}}
     )
     self.assertEqual("release/1.0", config.get_tag_for_version("1.0"))
 def test_check_keychain(self):
     config = BaseProjectConfig(BaseGlobalConfig())
     with self.assertRaises(KeychainNotFound):
         config._check_keychain()
 def test_get_static_dependencies(self):
     dep = {"namespace": "npsp", "version": "3"}
     config = BaseProjectConfig(
         BaseGlobalConfig(), {"project": {"dependencies": [dep]}}
     )
     self.assertEqual([dep], config.get_static_dependencies())
 def test_get_static_dependencies_no_dependencies(self):
     config = BaseProjectConfig(BaseGlobalConfig())
     self.assertEqual([], config.get_static_dependencies())
 def test_use_sentry(self):
     config = BaseProjectConfig(BaseGlobalConfig())
     config.keychain = mock.Mock()
     self.assertTrue(config.use_sentry)
    def test_process_github_dependency_latest(self):
        global_config = BaseGlobalConfig()
        config = BaseProjectConfig(global_config)
        config.keychain = DummyKeychain()
        github = self._make_github()
        github.repositories["CumulusCI-Test-Dep"]._releases = [
            DummyRelease("beta/1.1-Beta_1", "1.1 (Beta 1)"),
            DummyRelease("release/1.0", "1.0"),
        ]
        config.get_github_api = mock.Mock(return_value=github)

        result = config.process_github_dependency(
            {
                "github": "https://github.com/SFDO-Tooling/CumulusCI-Test.git",
                "unmanaged": True,
                "skip": ["unpackaged/pre/skip", "unpackaged/post/skip"],
            },
            "",
            include_beta=True,
        )
        self.assertEqual(
            result,
            [
                {
                    u"name": "Deploy unpackaged/pre/pre",
                    u"repo_owner": "SFDO-Tooling",
                    u"repo_name": "CumulusCI-Test",
                    u"ref": "commit_sha",
                    u"subfolder": u"unpackaged/pre/pre",
                    u"unmanaged": True,
                    u"namespace_inject": None,
                    u"namespace_strip": None,
                    u"namespace_tokenize": None,
                },
                {
                    u"name": "Install CumulusCI-Test-Dep 1.1 (Beta 1)",
                    u"version": "1.1 (Beta 1)",
                    u"namespace": "ccitestdep",
                },
                {
                    u"name": "Deploy CumulusCI-Test",
                    u"repo_owner": "SFDO-Tooling",
                    u"repo_name": "CumulusCI-Test",
                    u"ref": "commit_sha",
                    u"subfolder": u"src",
                    u"unmanaged": True,
                    u"namespace_inject": None,
                    u"namespace_strip": None,
                    u"namespace_tokenize": None,
                },
                {
                    u"name": "Deploy unpackaged/post/post",
                    u"repo_owner": "SFDO-Tooling",
                    u"repo_name": "CumulusCI-Test",
                    u"ref": "commit_sha",
                    u"subfolder": u"unpackaged/post/post",
                    u"unmanaged": True,
                    u"namespace_inject": "ccitest",
                    u"namespace_strip": None,
                    u"namespace_tokenize": None,
                },
            ],
        )