def test_kill_kernel_success(self):  # depends on start_kernel
        y = self.a.start_kernel()
        kernel_id = y["kernel_id"]
        assert_in(kernel_id, self.a._kernels)

        retval = self.a.kill_kernel(kernel_id)
        assert_is(retval, True)
        assert_not_in(kernel_id, self.a._kernels)
Exemple #2
0
    def test_kill_kernel_success(self):  # depends on start_kernel
        y = self.a.start_kernel()
        kernel_id = y["kernel_id"]
        assert_in(kernel_id, self.a._kernels)

        retval = self.a.kill_kernel(kernel_id)
        assert_is(retval, True)
        assert_not_in(kernel_id, self.a._kernels)
    def test_kill_kernel_success(self): # depends on start_kernel
        y = self.a.start_kernel()
        kernel_id = y["kernel_id"]
        proc = self.a.kernels[kernel_id][0]

        assert_is(proc.is_alive(), True)
        retval = self.a.kill_kernel(kernel_id)
        assert_is(retval, True)
        assert_not_in(kernel_id, self.a.kernels.keys())
        assert_is(proc.is_alive(), False)
Exemple #4
0
    def test_kill_kernel_success(self):  # depends on start_kernel
        y = self.a.start_kernel()
        kernel_id = y["kernel_id"]
        proc = self.a.kernels[kernel_id][0]

        assert_is(proc.is_alive(), True)
        retval = self.a.kill_kernel(kernel_id)
        assert_is(retval, True)
        assert_not_in(kernel_id, self.a.kernels.keys())
        assert_is(proc.is_alive(), False)
Exemple #5
0
 def test_get_kernel_ids_success(self):
     self._populate_comps_kernels()
     x = self.a.get_kernel_ids("testcomp1")
     y = self.a.get_kernel_ids("testcomp2")
     assert_len(x, 2)
     assert_len(y, 1)
     assert_in("kone", x)
     assert_in("ktwo", x)
     assert_not_in("kthree", x)
     assert_in("kthree", y)
 def test_get_kernel_ids_success(self):
     self._populate_comps_kernels()
     x = self.a.get_kernel_ids("testcomp1")
     y = self.a.get_kernel_ids("testcomp2")
     assert_len(x, 2)
     assert_len(y, 1)
     assert_in("kone", x)
     assert_in("ktwo", x)
     assert_not_in("kthree", x)
     assert_in("kthree", y)
Exemple #7
0
    def test_end_session_success(self): # depends on add_computer, new_session
        x = self.a.add_computer(self.default_comp_config)
        kern1 = self.a.new_session()
        kern2 = self.a.new_session()
        with capture_output(split=True) as (out,err):
            self.a.end_session(kern1)

        assert_not_in(kern1, self.a._kernels.keys())
        for v in self.a._comps.values():
            assert_not_in(kern1, v["kernels"])
        #assert_in("Killing Kernel ::: %s at "%kern1, out[0])
        #assert_in("Kernel %s successfully killed."%kern1, out[1])
        with capture_output(split=True) as (out,err):
            self.a.end_session(kern2)

        assert_not_in(kern2, self.a._kernels)
        for v in self.a._comps.values():
            assert_not_in(kern2, v["kernels"])
    def test_end_session_success(self):  # depends on add_computer, new_session
        x = self.a.add_computer(self.default_comp_config)
        kern1 = self.a.new_session()
        kern2 = self.a.new_session()
        with capture_output(split=True) as (out, err):
            self.a.end_session(kern1)

        assert_not_in(kern1, self.a._kernels.keys())
        for v in self.a._comps.values():
            assert_not_in(kern1, v["kernels"])
        # assert_in("Killing Kernel ::: %s at "%kern1, out[0])
        # assert_in("Kernel %s successfully killed."%kern1, out[1])
        with capture_output(split=True) as (out, err):
            self.a.end_session(kern2)

        assert_not_in(kern2, self.a._kernels)
        for v in self.a._comps.values():
            assert_not_in(kern2, v["kernels"])
Exemple #9
0
    def test_remove_computer_success(self): # depends on add_computer, new_session
        x = self.a.add_computer(self.default_comp_config)
        kern1 = self.a.new_session()
        kern2 = self.a.new_session()
        b = self.a.add_computer(self.default_comp_config)
        
        # remove computer with active kernels
        with capture_output() as (out, err):
                self.a.remove_computer(x)
        out = out[0]
        self._check_all_kernels_killed_out(out)
        assert_not_in(kern1, self.a._kernels)
        assert_not_in(kern2, self.a._kernels)
        assert_not_in(x, self.a._comps)

        # remove computer with no kernels
        with capture_output() as (out, err):
                self.a.remove_computer(b)
        out = out[0]
        self._check_all_kernels_killed_out(out)
        assert_not_in(b, self.a._comps)
    def test_remove_computer_success(self):  # depends on add_computer, new_session
        x = self.a.add_computer(self.default_comp_config)
        kern1 = self.a.new_session()
        kern2 = self.a.new_session()
        b = self.a.add_computer(self.default_comp_config)

        # remove computer with active kernels
        with capture_output() as (out, err):
            self.a.remove_computer(x)
        out = out[0]
        self._check_all_kernels_killed_out(out)
        assert_not_in(kern1, self.a._kernels)
        assert_not_in(kern2, self.a._kernels)
        assert_not_in(x, self.a._comps)

        # remove computer with no kernels
        with capture_output() as (out, err):
            self.a.remove_computer(b)
        out = out[0]
        self._check_all_kernels_killed_out(out)
        assert_not_in(b, self.a._comps)