Example #1
0
 def test_python_binary_config(self):
     config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
     context = SmContext(SmApplication(config_dir_override), None, False, False)
     starter = context.get_service_starter("PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND", "foo", proxy=None)
     expected = [ 'get_start_command() not implemented for this type of service - fork and make a pull request :)' ]
     cmd = starter.get_start_command("BINARY")
     self.assertEqual(cmd, expected)
Example #2
0
 def test_start_and_stop_one_with_append_args(self):
     config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
     context = SmContext(SmApplication(config_dir_override), None, False, False)
     actions.start_one(context, "TEST_ONE", True, False, None, None, ["; echo 'Fin du sleep!!'"])
     self.assertEquals(len(context.get_service("TEST_ONE").status()), 2) # it is two in this case because the append creates a forked process
     context.kill("TEST_ONE")
     self.assertEqual(context.get_service("TEST_ONE").status(), [])
Example #3
0
 def test_external_binary_config(self):
     config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
     context = SmContext(SmApplication(config_dir_override), None, False, False)
     starter = context.get_service_starter("FAKE_NEXUS", "foo", proxy=None)
     expected = [ 'python', 'fakenexus.py']
     cmd = starter.get_start_command("BINARY") #context will be ignored
     self.assertEqual(cmd, expected)
Example #4
0
 def test_python_binary_config(self):
     config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
     context = SmContext(SmApplication(config_dir_override), None, False, False)
     starter = context.get_service_starter("PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND", "foo", proxy=None)
     expected = ['python -m SimpleHTTPServer 9032']
     cmd = starter.get_start_command("BINARY")
     self.assertEqual(cmd, expected)
Example #5
0
 def test_start_and_stop_one(self):
     config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
     context = SmContext(SmApplication(config_dir_override), None, False, False)
     actions.start_one(context, "TEST_ONE", True, False, None, port=None)
     self.assertEquals(len(context.get_service("TEST_ONE").status()), 1)
     context.kill("TEST_ONE")
     self.assertEqual(context.get_service("TEST_ONE").status(), [])
Example #6
0
 def test_python_server_offline(self):
     config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
     context = SmContext(SmApplication(config_dir_override), None, True, False)
     actions.start_one(context, "PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND", True, False, None, port=None)
     self.assertIsNotNone(context.get_service("PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND").status())
     context.kill("PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND")
     time.sleep(5)
     self.assertEqual(context.get_service("PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND").status(), [])
Example #7
0
 def test_python_server_offline(self):
     context = SmContext(SmApplication(self.config_dir_override), None, True, False)
     port = None
     append_args = None
     actions.start_one(context, "PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND", False, True, False, None, port, append_args)
     self.assertIsNotNone(context.get_service("PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND").status())
     context.kill("PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND", True)
     self.assertEqual(context.get_service("PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND").status(), [])
Example #8
0
    def test_start_and_stop_one(self):
        context = SmContext(SmApplication(self.config_dir_override), None, False, False)
        result = actions.start_one(context, "TEST_ONE", False, True, False, None, port=None)
        self.assertTrue(result)

        self.waitForCondition((lambda : len(context.get_service("TEST_ONE").status())), 1)
        context.kill("TEST_ONE", True)
        self.assertEqual(context.get_service("TEST_ONE").status(), [])
Example #9
0
 def test_play_source_config(self):
     config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
     context = SmContext(SmApplication(config_dir_override), None, False, False)
     starter = context.get_service_starter("PLAY_NEXUS_END_TO_END_TEST", True, False, None, port=None)
     expected = [
         "play",
         "start -Dhttp.port=8500 -Dservice.manager.serviceName=PLAY_NEXUS_END_TO_END_TEST -Dservice.manager.runFrom=True -DFoo=false",
     ]
     self.assertEqual(starter.get_start_command("SOURCE"), expected)
Example #10
0
    def test_dropwizard_from_source(self):
        sm_application = SmApplication(self.config_dir_override)
        context = SmContext(sm_application, None, False, False)
        service_resolver = ServiceResolver(sm_application)

        servicetostart = "DROPWIZARD_NEXUS_END_TO_END_TEST"
        actions.start_and_wait(service_resolver, context, [servicetostart], False, False, False, None, port=None, seconds_to_wait=90, append_args=None)
        self.assertIsNotNone(context.get_service(servicetostart).status())
        context.kill(servicetostart, True)
        self.assertEqual(context.get_service(servicetostart).status(), [])
Example #11
0
 def test_external_with_invalid_append_args(self):
     config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
     context = SmContext(SmApplication(config_dir_override), None, False, False)
     context.kill_everything()
     server = smserverlogic.SmServer(SmApplication(config_dir_override, None))
     request = dict()
     request["testId"] = "foo"
     request["services"] = [{"serviceName": "TEST_ONE", "runFrom": "SNAPSHOT", "appendArgs": ";echo foo"}]
     with pytest.raises(BadRequestException):
         smserverlogic.SmStartRequest(server, request, True, False).process_request()
Example #12
0
 def test_start_and_stop_one_duplicate(self):
     config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
     context = SmContext(SmApplication(config_dir_override), None, False, False)
     response1 = actions.start_one(context, "TEST_ONE", False, True, False, None, port=None)
     self.assertTrue(response1)
     self.assertIsNotNone(context.get_service("TEST_ONE").status())
     response2 = actions.start_one(context, "TEST_ONE", False, True, False, None, port=None)
     self.assertFalse(response2)
     context.kill("TEST_ONE")
     self.assertEqual(context.get_service("TEST_ONE").status(), [])
Example #13
0
    def test_dropwizard_from_jar(self):
        config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
        sm_application = SmApplication(config_dir_override)
        context = SmContext(sm_application, None, False, False)
        service_resolver = ServiceResolver(sm_application)

        # start fake nexus
        actions.start_one(context, "FAKE_NEXUS", True, False, None, port=None)
        self.assertIsNotNone(context.get_service("FAKE_NEXUS").status())
        time.sleep(5)

        servicetostart = "DROPWIZARD_NEXUS_END_TO_END_TEST"
        actions.start_and_wait(
            service_resolver,
            context,
            [servicetostart],
            True,
            False,
            None,
            port=None,
            seconds_to_wait=90,
            append_args=None,
        )
        self.assertIsNotNone(context.get_service(servicetostart).status())
        context.kill(servicetostart)
        context.kill("FAKE_NEXUS")
        time.sleep(5)
        self.assertEqual(context.get_service(servicetostart).status(), [])
        self.assertEqual(context.get_service("FAKE_NEXUS").status(), [])
Example #14
0
    def test_dropwizard_from_source(self):
        config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
        sm_application = SmApplication(config_dir_override)
        context = SmContext(sm_application, None, False, False)
        service_resolver = ServiceResolver(sm_application)

        servicetostart = "DROPWIZARD_NEXUS_END_TO_END_TEST"
        actions.start_and_wait(service_resolver, context, [servicetostart], False, False, None, port=None, seconds_to_wait=90)
        self.assertIsNotNone(context.get_service(servicetostart).status())
        context.kill(servicetostart)
        self.assertEqual(context.get_service(servicetostart).status(), [])
Example #15
0
    def test_start_and_stop_one_duplicate(self):
        sm_application = SmApplication(self.config_dir_override)
        context = SmContext(sm_application, None, False, False)
        service_resolver = ServiceResolver(sm_application)

        actions.start_and_wait(service_resolver, context, ["TEST_ONE"], False, False, False, None, port=None, seconds_to_wait=90, append_args=None)

        self.assertIsNotNone(context.get_service("TEST_ONE").status())
        result = actions.start_one(context, "TEST_ONE", False, True, False, None, port=None)
        self.assertFalse(result)
        context.kill("TEST_ONE", True)
        self.assertEqual(context.get_service("TEST_ONE").status(), [])
Example #16
0
    def test_play_from_source_default(self):
        sm_application = SmApplication(self.config_dir_override)
        context = SmContext(sm_application, None, False, False)
        service_resolver = ServiceResolver(sm_application)

        servicetostart = "PLAY_NEXUS_END_TO_END_TEST"
        port = None
        secondsToWait = 90
        append_args = None
        actions.start_and_wait(service_resolver, context, [servicetostart], False, False, False, None, port, secondsToWait, append_args)
        self.assertIsNotNone(context.get_service(servicetostart).status())
        context.kill(servicetostart, True)
        self.assertEqual(context.get_service(servicetostart).status(), [])
Example #17
0
    def test_play_from_default_run_from_source(self):
        config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
        sm_application = SmApplication(config_dir_override)
        context = SmContext(sm_application, None, False, False)
        service_resolver = ServiceResolver(sm_application)

        servicetostart = "PLAY_NEXUS_END_TO_END_DEFAULT_SOURCE_TEST"
        port = None
        secondsToWait = 90
        append_args = None
        actions.start_and_wait(service_resolver, context, [servicetostart], False, False, False, None, port, secondsToWait, append_args)
        self.assertIsNotNone(context.get_service(servicetostart).status())
        context.kill(servicetostart)
        self.assertEqual(context.get_service(servicetostart).status(), [])
Example #18
0
    def test_play_with_append_args(self):
        config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
        context = SmContext(SmApplication(config_dir_override), None, False, False)
        context.kill_everything()

        # Start up fake nexus first
        response1 = actions.start_one(context, "FAKE_NEXUS", True, False, None, port=None)
        self.assertTrue(response1)
        self.assertIsNotNone(context.get_service("FAKE_NEXUS").status())
        time.sleep(5)

        server = smserverlogic.SmServer(SmApplication(config_dir_override, None))
        request = dict()
        request["testId"] = "foo"
        request["services"] = [
            {"serviceName": "PLAY_NEXUS_END_TO_END_TEST", "runFrom": "SNAPSHOT", "appendArgs": ["-Dfoo=bar"]}
        ]
        smserverlogic.SmStartRequest(server, request, True, False).process_request()
        time.sleep(5)
        self.assertEqual(len(context.get_service("PLAY_NEXUS_END_TO_END_TEST").status()), 1)
        service = SmPlayService(context, "PLAY_NEXUS_END_TO_END_TEST")
        processes = SmProcess.processes_matching(service.pattern)
        self.assertEqual(len(processes), 1)
        self.assertTrue("-Dfoo=bar" in processes[0].args)
        context.kill_everything()
        self.assertEqual(context.get_service("TEST_ONE").status(), [])
Example #19
0
 def test_play_binary_config(self):
     config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
     context = SmContext(SmApplication(config_dir_override), None, False, False)
     starter = context.get_service_starter("PLAY_NEXUS_END_TO_END_TEST", True, False, None, port=None)
     #starter = SmPlayServiceStarter(context, "PLAY_NEXUS_END_TO_END_TEST", True, False, None, None, None, None)
     expected = [ './basicplayapp/bin/basicplayapp',
                             '-DProd.microservice.whitelist.useWhitelist=false',
                             '-DProd.mongodb.uri=mongodb://localhost:27017/auth',
                             '-J-Xmx256m',
                             '-J-Xms256m',
                             '-J-XX:MaxPermSize=128m',
                             '-Dhttp.port=8500',
                             '-Dservice.manager.serviceName=PLAY_NEXUS_END_TO_END_TEST',
                             '-Dservice.manager.runFrom=True']
     self.assertEqual(starter.get_start_command("BINARY"), expected)
Example #20
0
    def test_failing_play_from_jar(self):

        sm_application = SmApplication(self.config_dir_override)
        context = SmContext(sm_application, None, False, False)
        service_resolver = ServiceResolver(sm_application)

        context.kill_everything(True)

        self.startFakeNexus()

        try:
            servicetostart = ["BROKEN_PLAY_PROJECT"]
            actions.start_and_wait(service_resolver, context, servicetostart, source=False, fatjar=True, release=False, proxy=None, port=None, seconds_to_wait=2, append_args=None)
            self.fail("Did not expect the project to startup.")
        except ServiceManagerException as sme:
            self.assertEqual("Timed out starting service(s): BROKEN_PLAY_PROJECT", sme.message)
        finally:
            context.kill_everything(True)
Example #21
0
    def test_nexus_tgz(self):
        config_dir_override = os.path.join(os.path.dirname(__file__), "conf")

        # start fake nexus
        context = SmContext(SmApplication(config_dir_override), None, False, False)
        response1 = actions.start_one(context, "FAKE_NEXUS", True, False, None, port=None)
        self.assertIsNotNone(context.get_service("FAKE_NEXUS").status())
        time.sleep(5)

        context = SmContext(SmApplication(config_dir_override), None, False, False)
        servicetostart = "PLAY_NEXUS_TGZ_TEST"
        actions.start_one(context, servicetostart, True, False, None, port=None)
        self.assertIsNotNone(context.get_service(servicetostart).status())
        context.kill(servicetostart)

        context.kill("FAKE_NEXUS")

        self.assertEqual(context.get_service(servicetostart).status(), [])
        self.assertEqual(context.get_service("FAKE_NEXUS").status(), [])
Example #22
0
    def test_successful_play_from_jar_without_waiting(self):
        sm_application = SmApplication(self.config_dir_override)
        context = SmContext(sm_application, None, False, False)
        service_resolver = ServiceResolver(sm_application)

        context.kill_everything(True)

        self.startFakeNexus()

        fatJar = True
        release = False
        proxy = None
        port = None
        seconds_to_wait = None
        append_args = None

        try:
            servicetostart = ["PLAY_NEXUS_END_TO_END_TEST"]
            actions.start_and_wait(service_resolver, context, servicetostart, False, fatJar, release, proxy, port, seconds_to_wait, append_args)
        finally:
            context.kill_everything(True)
Example #23
0
    def test_successful_play_from_jar_without_waiting_with_append_args(self):
        config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
        sm_application = SmApplication(config_dir_override)
        context = SmContext(sm_application, None, False, False)
        service_resolver = ServiceResolver(sm_application)

        context.kill_everything()
        time.sleep(5)

        response1 = actions.start_one(context, "FAKE_NEXUS", True, False, None, None, None)
        self.assertTrue(response1)
        self.assertIsNotNone(context.get_service("FAKE_NEXUS").status())
        time.sleep(5)

        servicetostart = ["PLAY_NEXUS_END_TO_END_TEST"]
        appendArgs = {"PLAY_NEXUS_END_TO_END_TEST": ["-DFoo=Bar"]}
        fatJar = True
        release = False
        proxy = None
        port = None
        seconds_to_wait = None

        try:
            actions.start_and_wait(service_resolver, context, servicetostart, fatJar, release, proxy, port, seconds_to_wait, appendArgs)
            time.sleep(5)
            service = SmPlayService(context, "PLAY_NEXUS_END_TO_END_TEST")
            processes = SmProcess.processes_matching(service.pattern)
            self.assertEqual(len(processes), 1)
            self.assertTrue("-DFoo=Bar" in processes[0].args)
        finally:
            context.kill_everything()
Example #24
0
    def test_failing_play_from_jar(self):

        config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
        sm_application = SmApplication(config_dir_override)
        context = SmContext(sm_application, None, False, False)
        service_resolver = ServiceResolver(sm_application)

        context.kill_everything()
        time.sleep(5)

        response1 = actions.start_one(context, "FAKE_NEXUS", True, False, None, port=None)
        self.assertTrue(response1)
        self.assertIsNotNone(context.get_service("FAKE_NEXUS").status())
        time.sleep(5)

        try:
            servicetostart = ["BROKEN_PLAY_PROJECT"]
            actions.start_and_wait(
                service_resolver,
                context,
                servicetostart,
                fatjar=True,
                release=False,
                proxy=None,
                port=None,
                seconds_to_wait=2,
                append_args=None,
            )
            self.fail("Did not expect the project to startup.")
        except ServiceManagerException as sme:
            self.assertEqual("Timed out starting service(s): BROKEN_PLAY_PROJECT", sme.message)
        finally:
            context.kill_everything()
Example #25
0
    def test_successful_play_from_jar_without_waiting(self):
        config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
        sm_application = SmApplication(config_dir_override)
        context = SmContext(sm_application, None, False, False)
        service_resolver = ServiceResolver(sm_application)

        context.kill_everything()
        time.sleep(5)

        response1 = actions.start_one(context, "FAKE_NEXUS", True, False, None, port=None)
        self.assertTrue(response1)
        self.assertIsNotNone(context.get_service("FAKE_NEXUS").status())
        time.sleep(5)

        fatJar = True
        release = False
        proxy = None
        port = None
        seconds_to_wait = None
        append_args = None

        try:
            servicetostart = ["PLAY_NEXUS_END_TO_END_TEST"]
            actions.start_and_wait(service_resolver, context, servicetostart, fatJar, release, proxy, port, seconds_to_wait, append_args)
        finally:
            context.kill_everything()
Example #26
0
    def test_successful_play_from_jar_without_waiting_with_append_args(self):
        sm_application = SmApplication(self.config_dir_override)
        context = SmContext(sm_application, None, False, False)
        service_resolver = ServiceResolver(sm_application)

        context.kill_everything(True)

        self.startFakeNexus()

        servicetostart = ["PLAY_NEXUS_END_TO_END_TEST"]
        appendArgs = {"PLAY_NEXUS_END_TO_END_TEST": ["-DFoo=Bar"]}
        fatJar = True
        release = False
        proxy = None
        port = None
        seconds_to_wait = None

        actions.start_and_wait(service_resolver, context, servicetostart, False, fatJar, release, proxy, port, seconds_to_wait, appendArgs)
        service = SmPlayService(context, "PLAY_NEXUS_END_TO_END_TEST")
        self.waitForCondition(lambda : len(SmProcess.processes_matching(service.pattern)), 1)
        processes = SmProcess.processes_matching(service.pattern)
        self.assertTrue("-DFoo=Bar" in processes[0].args)
Example #27
0
    def test_assets_server(self):
        context = SmContext(SmApplication(self.config_dir_override), None, False, False)
        context.kill_everything(True)

        self.startFakeNexus()

        actions.start_one(context, "PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND", False, True, False, None, port=None)
        self.assertIsNotNone(context.get_service("PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND").status())
        context.kill("PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND", wait=True)

        self.assertEqual(context.get_service("PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND").status(), [])
Example #28
0
    def test_bintray(self):
        config_dir_override = os.path.join(os.path.dirname(__file__), "conf")

        # start fake bintray
        context = SmContext(SmApplication(config_dir_override), None, False, False)
        response1 = actions.start_one(context, "FAKE_BINTRAY", False, True, False, None, port=None)
        self.assertIsNotNone(context.get_service("FAKE_BINTRAY").status())
        time.sleep(5)

        context = SmContext(SmApplication(config_dir_override), None, False, False)
        servicetostart = "PLAY_BINTRAY_END_TO_END_TEST"
        actions.start_one(context, servicetostart, False, True, False, None, port=None)
        self.assertIsNotNone(context.get_service(servicetostart).status())
        context.kill(servicetostart)

        context.kill("FAKE_BINTRAY")

        self.assertEqual(context.get_service(servicetostart).status(), [])
        self.assertEqual(context.get_service("FAKE_BINTRAY").status(), [])
Example #29
0
    def test_file_server(self):
        name = "FAKE_NEXUS"
        config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
        context = SmContext(SmApplication(config_dir_override), None, False, False)

        context.kill(name)
        self.assertEqual(context.get_service(name).status(), [])
        time.sleep(2)

        response1 = actions.start_one(context, name, True, False, None, port=None)
        self.assertTrue(response1)
        self.assertIsNotNone(context.get_service(name).status())
        response2 = actions.start_one(context, name, True, False, None, port=None)
        self.assertFalse(response2)
        context.kill(name)
        self.assertEqual(context.get_service(name).status(), [])
Example #30
0
 def test_dropwizard_binary_config(self):
     config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
     context = SmContext(SmApplication(config_dir_override), None, False, False)
     starter = context.get_service_starter("DROPWIZARD_NEXUS_END_TO_END_TEST", "foo", proxy=None)
     expected = [
         'java',
         '-Dfile.encoding=UTF8',
         '-Xmx64M',
         '-XX:+CMSClassUnloadingEnabled',
         '-XX:MaxPermSize=64m',
         '-Ddw.http.port=8080',
         '-Dservice.manager.serviceName=DROPWIZARD_NEXUS_END_TO_END_TEST',
         '-Dservice.manager.serviceName=DROPWIZARD_NEXUS_END_TO_END_TEST',
         '-Dservice.manager.runFrom=foo',
         '-jar',
         'dwtest-foo-shaded.jar',
         'server',
         'dev_config.yml']
     cmd = starter.get_start_command("BINARY")
     cmd[-1] = cmd[-1].split("/")[-1]
     cmd[0] = cmd[0].split("/")[-1]
     cmd[len(cmd) -3] = cmd[len(cmd) -3].split("/")[-1]
     self.assertEqual(cmd, expected)
Example #31
0
    def test_play_from_source(self):
        config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
        sm_application = SmApplication(config_dir_override)
        context = SmContext(sm_application, None, False, False)
        service_resolver = ServiceResolver(sm_application)

        servicetostart = "PLAY_NEXUS_END_TO_END_TEST"
        actions.start_and_wait(service_resolver,
                               context, [servicetostart],
                               False,
                               False,
                               None,
                               port=None,
                               seconds_to_wait=90)
        self.assertIsNotNone(context.get_service(servicetostart).status())
        context.kill(servicetostart)
        self.assertEqual(context.get_service(servicetostart).status(), [])
Example #32
0
    def test_dropwizard_from_source(self):
        sm_application = SmApplication(self.config_dir_override)
        context = SmContext(sm_application, None, False, False)
        service_resolver = ServiceResolver(sm_application)

        servicetostart = "DROPWIZARD_NEXUS_END_TO_END_TEST"
        actions.start_and_wait(service_resolver,
                               context, [servicetostart],
                               False,
                               False,
                               False,
                               None,
                               port=None,
                               seconds_to_wait=90,
                               append_args=None)
        self.assertIsNotNone(context.get_service(servicetostart).status())
        context.kill(servicetostart, True)
        self.assertEqual(context.get_service(servicetostart).status(), [])
Example #33
0
 def test_python_server_offline(self):
     config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
     context = SmContext(SmApplication(config_dir_override), None, True,
                         False)
     actions.start_one(context,
                       "PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND",
                       True,
                       False,
                       None,
                       port=None)
     self.assertIsNotNone(
         context.get_service(
             "PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND").status())
     context.kill("PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND")
     time.sleep(5)
     self.assertEqual(
         context.get_service(
             "PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND").status(), [])
Example #34
0
    def test_failing_play_from_jar(self):

        config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
        sm_application = SmApplication(config_dir_override)
        context = SmContext(sm_application, None, False, False)
        service_resolver = ServiceResolver(sm_application)

        context.kill_everything()
        time.sleep(5)

        response1 = actions.start_one(context,
                                      "FAKE_NEXUS",
                                      True,
                                      False,
                                      None,
                                      port=None)
        self.assertTrue(response1)
        self.assertIsNotNone(context.get_service("FAKE_NEXUS").status())
        time.sleep(5)

        try:
            servicetostart = ["BROKEN_PLAY_PROJECT"]
            actions.start_and_wait(service_resolver,
                                   context,
                                   servicetostart,
                                   fatjar=True,
                                   release=False,
                                   proxy=None,
                                   port=None,
                                   seconds_to_wait=2,
                                   append_args=None)
            self.fail("Did not expect the project to startup.")
        except ServiceManagerException as sme:
            self.assertEqual(
                "Timed out starting service(s): BROKEN_PLAY_PROJECT",
                sme.message)
        finally:
            context.kill_everything()
Example #35
0
 def test_start_and_stop_one_duplicate(self):
     config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
     context = SmContext(SmApplication(config_dir_override), None, False,
                         False)
     response1 = actions.start_one(context,
                                   "TEST_ONE",
                                   True,
                                   False,
                                   None,
                                   port=None)
     self.assertTrue(response1)
     self.assertIsNotNone(context.get_service("TEST_ONE").status())
     response2 = actions.start_one(context,
                                   "TEST_ONE",
                                   True,
                                   False,
                                   None,
                                   port=None)
     self.assertFalse(response2)
     context.kill("TEST_ONE")
     self.assertEqual(context.get_service("TEST_ONE").status(), [])
Example #36
0
    def test_successful_play_from_jar_without_waiting(self):
        sm_application = SmApplication(self.config_dir_override)
        context = SmContext(sm_application, None, False, False)
        service_resolver = ServiceResolver(sm_application)

        context.kill_everything(True)

        self.startFakeNexus()

        fatJar = True
        release = False
        proxy = None
        port = None
        seconds_to_wait = None
        append_args = None

        try:
            servicetostart = ["PLAY_NEXUS_END_TO_END_TEST"]
            actions.start_and_wait(service_resolver, context, servicetostart,
                                   False, fatJar, release, proxy, port,
                                   seconds_to_wait, append_args)
        finally:
            context.kill_everything(True)
Example #37
0
    def test_start_and_stop_one_duplicate(self):
        sm_application = SmApplication(self.config_dir_override)
        context = SmContext(sm_application, None, False, False)
        service_resolver = ServiceResolver(sm_application)

        actions.start_and_wait(
            service_resolver,
            context,
            ["TEST_ONE"],
            False,
            False,
            False,
            None,
            port=None,
            seconds_to_wait=90,
            append_args=None,
        )

        self.assertIsNotNone(context.get_service("TEST_ONE").status())
        result = actions.start_one(context, "TEST_ONE", False, True, False, None, port=None)
        self.assertFalse(result)
        context.kill("TEST_ONE", True)
        self.assertEqual(context.get_service("TEST_ONE").status(), [])
Example #38
0
 def test_runfrom_override(self):
     context = SmContext(SmApplication(self.config_dir_override), None, False, False)
     python_server = context.get_service("PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND")
     run_from = context.get_run_from_service_override_value_or_use_default(python_server, "SHOULD_BE_OVERWRITTEN")
     self.assertEqual(run_from, "RELEASE")
Example #39
0
 def test_external_source_config(self):
     config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
     context = SmContext(SmApplication(config_dir_override), None, False, False)
     starter = context.get_service_starter("FAKE_NEXUS", "foo", proxy=None)
     expected = [ 'python', 'fakenexus.py']
     self.assertEqual(starter.get_start_command("SOURCE"), expected) #context will be ignored
 def setUp(self):
     sm_application = SmApplication(self.test_dir + "conf/", features={})
     sm_context = SmContext(sm_application, "")
     self.sm_play_service = SmPlayServiceStarter(
         sm_context, "PLAY_NEXUS_END_TO_END_TEST", "", "", 9000, "", "", "",
         "")
Example #41
0
    def test_nexus(self):
        config_dir_override = os.path.join(os.path.dirname(__file__), "conf")

        # start fake nexus
        context = SmContext(SmApplication(config_dir_override), None, False,
                            False)
        response1 = actions.start_one(context,
                                      "FAKE_NEXUS",
                                      True,
                                      False,
                                      None,
                                      port=None)
        self.assertIsNotNone(context.get_service("FAKE_NEXUS").status())
        time.sleep(5)

        context = SmContext(SmApplication(config_dir_override), None, False,
                            False)
        servicetostart = "PLAY_NEXUS_END_TO_END_TEST"
        actions.start_one(context,
                          servicetostart,
                          True,
                          False,
                          None,
                          port=None)
        self.assertIsNotNone(context.get_service(servicetostart).status())
        context.kill(servicetostart)

        context.kill("FAKE_NEXUS")

        self.assertEqual(context.get_service(servicetostart).status(), [])
        self.assertEqual(context.get_service("FAKE_NEXUS").status(), [])
Example #42
0
 def test_offline(self):
     config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
     context = SmContext(SmApplication(config_dir_override), None, False,
                         False)
     context.kill_everything()
     server = smserverlogic.SmServer(
         SmApplication(config_dir_override, None))
     request = dict()
     request["testId"] = "foo"
     request["services"] = [{
         "serviceName": "TEST_ONE",
         "runFrom": "SNAPSHOT"
     }, {
         "serviceName": "DROPWIZARD_NEXUS_END_TO_END_TEST",
         "runFrom": "SNAPSHOT"
     }, {
         "serviceName": "PLAY_NEXUS_END_TO_END_TEST",
         "runFrom": "SNAPSHOT"
     }]
     smserverlogic.SmStartRequest(server, request, True,
                                  False).process_request()
     self.assertIsNotNone(context.get_service("TEST_ONE").status())
     # stop does not currently work for extern
     # smserverlogic.SmStopRequest(SERVER, request).process_request()
     context.kill_everything()
     self.assertEqual(context.get_service("TEST_ONE").status(), [])
     request["testId"] = "foo2"
     smserverlogic.SmStartRequest(server, request, True,
                                  True).process_request()
     self.assertIsNotNone(context.get_service("TEST_ONE").status())
     # stop does not currently work for extern
     #smserverlogic.SmStopRequest(SERVER, request).process_request()
     context.kill_everything()
     self.assertEqual(context.get_service("TEST_ONE").status(), [])
Example #43
0
    def test_assets_server(self):
        config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
        context = SmContext(SmApplication(config_dir_override), None, False,
                            False)
        context.kill_everything()

        context.kill("FAKE_NEXUS")
        self.assertEqual(context.get_service("FAKE_NEXUS").status(), [])
        time.sleep(2)

        # start fake nexus
        self.assertEqual(context.get_service("FAKE_NEXUS").status(), [])
        response1 = actions.start_one(context,
                                      "FAKE_NEXUS",
                                      True,
                                      False,
                                      None,
                                      port=None)
        self.assertTrue(response1)
        self.assertIsNotNone(context.get_service("FAKE_NEXUS").status())
        time.sleep(5)

        actions.start_one(context,
                          "PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND",
                          True,
                          False,
                          None,
                          port=None)
        self.assertIsNotNone(
            context.get_service(
                "PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND").status())
        context.kill("PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND")
        context.kill("FAKE_NEXUS")
        time.sleep(15)

        self.assertEqual(
            context.get_service(
                "PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND").status(), [])
        self.assertEqual(context.get_service("FAKE_NEXUS").status(), [])
Example #44
0
 def test_start_and_stop_one_with_append_args(self):
     context = SmContext(SmApplication(self.config_dir_override), None, False, False)
     actions.start_one(context, "TEST_FOUR", False, True, False, None, None, ["2"])
     self.waitForCondition((lambda: len(context.get_service("TEST_FOUR").status())), 1)
     context.kill("TEST_FOUR", True)
     self.assertEqual(context.get_service("TEST_FOUR").status(), [])
Example #45
0
    def test_wait_on_assets_server(self):
        config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
        sm_application = SmApplication(config_dir_override)
        context = SmContext(sm_application, None, False, False)
        service_resolver = ServiceResolver(sm_application)
        context.kill_everything()

        context.kill("FAKE_NEXUS")
        self.assertEqual(context.get_service("FAKE_NEXUS").status(), [])
        time.sleep(2)

        # start fake nexus
        self.assertEqual(context.get_service("FAKE_NEXUS").status(), [])
        response1 = actions.start_one(context,
                                      "FAKE_NEXUS",
                                      True,
                                      False,
                                      None,
                                      port=None)
        self.assertTrue(response1)
        self.assertIsNotNone(context.get_service("FAKE_NEXUS").status())
        time.sleep(5)

        port = None
        seconds_to_wait = 5
        append_args = None
        actions.start_and_wait(service_resolver, context,
                               ["PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND"], True,
                               False, None, port, seconds_to_wait, append_args)
        self.assertIsNotNone(
            context.get_service(
                "PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND").status())
        context.kill("PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND")
        context.kill("FAKE_NEXUS")
        time.sleep(15)

        self.assertEqual(
            context.get_service(
                "PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND").status(), [])
        self.assertEqual(context.get_service("FAKE_NEXUS").status(), [])
Example #46
0
 def test_python_source_config(self):
     config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
     context = SmContext(SmApplication(config_dir_override), None, False, False)
     starter = context.get_service_starter("PYTHON_SIMPLE_SERVER_ASSETS_FRONTEND", "foo", proxy=None)
     expected = ['python -m SimpleHTTPServer 9032']
     self.assertEqual(starter.get_start_command("SOURCE"), expected)
Example #47
0
    def test_ensure_multiple_instances_of_a_service_can_be_started_from_server(
            self):
        config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
        context = SmContext(SmApplication(config_dir_override), None, False,
                            False)
        context.kill_everything()
        server = smserverlogic.SmServer(
            SmApplication(config_dir_override, None))

        # start fake nexus
        self.assertEqual(context.get_service("FAKE_NEXUS").status(), [])
        response1 = actions.start_one(context,
                                      "FAKE_NEXUS",
                                      True,
                                      False,
                                      None,
                                      port=None)
        self.assertTrue(response1)
        self.assertIsNotNone(context.get_service("FAKE_NEXUS").status())
        time.sleep(5)

        first_request = dict()
        first_request["testId"] = "multiple-instance-unit-test-1"
        first_request["services"] = [{
            "serviceName": "TEST_ONE",
            "runFrom": "SNAPSHOT"
        }, {
            "serviceName": "DROPWIZARD_NEXUS_END_TO_END_TEST",
            "runFrom": "SNAPSHOT"
        }, {
            "serviceName": "PLAY_NEXUS_END_TO_END_TEST",
            "runFrom": "SNAPSHOT"
        }]
        request = smserverlogic.SmStartRequest(server, first_request, True,
                                               False)
        request.process_request()

        time.sleep(5)
        self.assertEqual(len(context.get_service("TEST_ONE").status()), 1)
        self.assertEqual(
            len(
                context.get_service(
                    "DROPWIZARD_NEXUS_END_TO_END_TEST").status()), 1)
        self.assertEqual(
            len(context.get_service("PLAY_NEXUS_END_TO_END_TEST").status()), 1)

        second_request = dict()
        second_request["testId"] = "multiple-instance-unit-test-2"
        second_request["services"] = [{
            "serviceName": "TEST_ONE",
            "runFrom": "SNAPSHOT"
        }, {
            "serviceName": "DROPWIZARD_NEXUS_END_TO_END_TEST",
            "runFrom": "SNAPSHOT"
        }, {
            "serviceName": "PLAY_NEXUS_END_TO_END_TEST",
            "runFrom": "SNAPSHOT"
        }]
        smserverlogic.SmStartRequest(server, second_request, True,
                                     False).process_request()
        time.sleep(5)
        self.assertEqual(len(context.get_service("TEST_ONE").status()), 2)
        self.assertEqual(
            len(
                context.get_service(
                    "DROPWIZARD_NEXUS_END_TO_END_TEST").status()), 2)
        self.assertEqual(
            len(context.get_service("PLAY_NEXUS_END_TO_END_TEST").status()), 2)

        # stop does not currently work for extern
        # smserverlogic.SmStopRequest(SERVER, request).process_request()
        context.kill_everything()
        self.assertEqual(context.get_service("TEST_ONE").status(), [])
        context.kill("FAKE_NEXUS")
Example #48
0
 def test_dropwizard_source_config(self):
     config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
     context = SmContext(SmApplication(config_dir_override), None, False, False)
     starter = context.get_service_starter("DROPWIZARD_NEXUS_END_TO_END_TEST", "foo", proxy=None)
     expected = ['./startappfromcode.sh']
     self.assertEqual(starter.get_start_command("SOURCE"), expected)
Example #49
0
 def createContext(self):
     return SmContext(SmApplication(self.config_dir_override), None, False,
                      False)
Example #50
0
 def test_play_source_config(self):
     config_dir_override = os.path.join(os.path.dirname(__file__), "conf")
     context = SmContext(SmApplication(config_dir_override), None, False, False)
     starter = context.get_service_starter("PLAY_NEXUS_END_TO_END_TEST", True, False, None, port=None)
     expected = [ 'play', 'start -Dhttp.port=8500 -Dservice.manager.serviceName=PLAY_NEXUS_END_TO_END_TEST -Dservice.manager.runFrom=True -DFoo=false']
     self.assertEqual(starter.get_start_command("SOURCE"), expected)