def test_process_once(self, p, q): main.main( ("--cwd", cwd(), "process", "-r", "1234"), standalone_mode=False ) p.assert_called_once_with("1234") q.assert_called_once()
def test_submit_abort(self, p, capsys): p.side_effect = KeyboardInterrupt main.main(( "--cwd", cwd(), "submit", Files.create(cwd(), "a.txt", "hello") ), standalone_mode=False) out, _ = capsys.readouterr() assert "Aborting submission of" in out
def test_community(self): with mock.patch("cuckoo.main.fetch_community") as p: p.return_value = None main.main(("--cwd", cwd(), "community"), standalone_mode=False) p.assert_called_once_with( force=False, branch="master", filepath=None )
def test_process_many(self, p, q): main.main( ("--cwd", cwd(), "process", "instance"), standalone_mode=False ) p.assert_called_once_with("instance", 0) q.assert_called_once()
def test_import_noconfirm(self, p): set_cwd(tempfile.mkdtemp()) p.side_effect = True, False dirpath = init_legacy_analyses() os.makedirs(os.path.join(dirpath, "lib", "cuckoo", "common")) open(os.path.join( dirpath, "lib", "cuckoo", "common", "constants.py" ), "wb").write(constants_11_py) shutil.copytree( "tests/files/conf/110_plain", os.path.join(dirpath, "conf") ) filepath = os.path.join(dirpath, "conf", "cuckoo.conf") buf = open(filepath, "rb").read() open(filepath, "wb").write(buf.replace( "connection =", "connection = %s" % self.URI )) main.main( ("--cwd", cwd(), "import", dirpath), standalone_mode=False ) db = Database() db.connect() assert db.engine.name == self.ENGINE assert open(cwd("logs", "a.txt", analysis=1), "rb").read() == "a" assert config("cuckoo:database:connection") == self.URI assert db.count_tasks() == 2
def test_import_confirm(self, p): set_cwd(tempfile.mkdtemp()) p.return_value = True dirpath = init_legacy_analyses() os.makedirs(os.path.join(dirpath, "lib", "cuckoo", "common")) open(os.path.join( dirpath, "lib", "cuckoo", "common", "constants.py" ), "wb").write(constants_11_py) shutil.copytree( "tests/files/conf/110_plain", os.path.join(dirpath, "conf") ) filepath = os.path.join(dirpath, "conf", "cuckoo.conf") buf = open(filepath, "rb").read() open(filepath, "wb").write(buf.replace( "connection =", "connection = %s" % self.URI )) try: main.main( ("--cwd", cwd(), "import", dirpath), standalone_mode=False ) except CuckooOperationalError as e: assert "SQL database dump as the command" in e.message assert not is_linux() return db = Database() db.connect() assert db.engine.name == self.ENGINE assert open(cwd("logs", "a.txt", analysis=1), "rb").read() == "a" assert config("cuckoo:database:connection") == self.URI assert db.count_tasks() == 2
def test_process_json_logging(): set_cwd(tempfile.mkdtemp()) cuckoo_create() init_yara() init_logfile("process-p0.json") def process_tasks(instance, maxcount): logger("foo bar", action="hello.world", status="success") with mock.patch("cuckoo.main.Database"): with mock.patch("cuckoo.main.process_tasks") as p1: with mock.patch("time.time") as p2: p1.side_effect = process_tasks p2.return_value = 1484232003 main.main( ("--cwd", cwd(), "process", "p0"), standalone_mode=False ) assert json.load(open(cwd("log", "process-p0.json"), "rb")) == { "asctime": mock.ANY, "action": "hello.world", "level": "info", "message": "foo bar", "status": "success", "task_id": None, "time": 1484232003, }
def test_cuckoo_init_main(self): """Tests that 'cuckoo' works with a new CWD.""" main.main( ("--cwd", cwd(), "--nolog"), standalone_mode=False ) assert os.path.exists(os.path.join(cwd(), "mitm.py"))
def test_cuckoo_init_no_resultserver(self): """Tests that 'cuckoo init' doesn't launch the ResultServer.""" with pytest.raises(SystemExit): main.main( ("--cwd", cwd(), "--nolog", "init"), standalone_mode=False ) # We copy the monitor binary directory over from user-CWD (which is # also present in the Travis CI environment, etc) as otherwise the # following call will raise an exception about not having found the # monitoring binaries. shutil.rmtree(os.path.join(cwd(), "monitor")) shutil.copytree( os.path.expanduser("~/.cuckoo/monitor"), os.path.join(cwd(), "monitor") ) # Raises CuckooCriticalError if ResultServer can't bind (which no # longer happens now, naturally). main.main( ("--cwd", cwd(), "--nolog", "init"), standalone_mode=False ) assert ResultServer not in Singleton._instances
def test_main_exception(self, p, q): q.side_effect = Exception("this is a test") with pytest.raises(SystemExit): main.main( ("--cwd", cwd(), "-d", "--nolog"), standalone_mode=False ) p.exception.assert_called_once()
def migrate(cls): tasks = cls.d.engine.execute( "SELECT status FROM tasks ORDER BY id" ).fetchall() assert tasks[0][0] == "success" assert tasks[1][0] == "processing" assert tasks[2][0] == "pending" main.main( ("--cwd", cwd(), "migrate", "--revision", "263a45963c72"), standalone_mode=False ) tasks = cls.d.engine.execute( "SELECT status FROM tasks ORDER BY id" ).fetchall() assert tasks[0][0] == "completed" assert tasks[1][0] == "running" assert tasks[2][0] == "pending" main.main( ("--cwd", cwd(), "migrate"), standalone_mode=False ) tasks = cls.d.engine.execute( "SELECT status, owner FROM tasks ORDER BY id" ).fetchall() assert tasks[0][0] == "completed" assert tasks[0][1] is None assert tasks[1][0] == "running" assert tasks[2][0] == "pending"
def test_dist_server(self): with mock.patch("cuckoo.main.cuckoo_distributed") as p: p.return_value = None main.main( ("--cwd", cwd(), "distributed", "server"), standalone_mode=False ) p.assert_called_once_with("localhost", 9003, False)
def test_main(self, p, q): p.side_effect = SystemExit(0) # Ensure that the "latest" binary value makes sense so that the # "run community command" exception is not thrown. mkdir(cwd("monitor", open(cwd("monitor", "latest")).read().strip())) main.main(("--cwd", cwd(), "-d", "--nolog"), standalone_mode=False) q.assert_called_once()
def test_dist_instance(self): with mock.patch("cuckoo.main.cuckoo_distributed_instance") as p: p.return_value = None main.main( ("--cwd", cwd(), "distributed", "instance", "name"), standalone_mode=False ) p.assert_called_once_with("name")
def test_import_noconfirm(self, p, capsys): p.return_value = False with pytest.raises(SystemExit) as e: main.main( ("--cwd", cwd(), "import", tempfile.mkdtemp()), standalone_mode=False ) e.match("Aborting operation")
def test_cuckoo_init_main_nosigs(self, p): """Ensure load_signatures() isn't called for 'cuckoo' with new CWD.""" main.main( ("--cwd", cwd(), "--nolog"), standalone_mode=False ) assert os.path.exists(os.path.join(cwd(), "mitm.py")) p.assert_not_called()
def test_process_abort(self, p, q, capsys): p.side_effect = KeyboardInterrupt main.main( ("--cwd", cwd(), "process", "-r", "1234"), standalone_mode=False ) out, _ = capsys.readouterr() assert "Aborting (re-)processing of your analyses" in out
def test_init(p): set_cwd(tempfile.mkdtemp()) with pytest.raises(SystemExit): main.main( ("--cwd", cwd(), "--nolog", "init"), standalone_mode=False ) p.assert_not_called()
def test_import_abort(self, p, q, capsys): p.side_effect = KeyboardInterrupt q.return_value = True main.main( ("--cwd", cwd(), "import", tempfile.mkdtemp()), standalone_mode=False ) out, _ = capsys.readouterr() assert "Aborting import of Cuckoo instance" in out
def test_web_noargs(self, p): curdir = os.getcwd() main.main(("--cwd", cwd(), "web"), standalone_mode=False) p.assert_called_once_with( ("cuckoo", "runserver", "localhost:8000") ) os.chdir(curdir)
def test_web_args(self, p): curdir = os.getcwd() main.main( ("--cwd", cwd(), "web", "foo", "bar"), standalone_mode=False ) p.assert_called_once_with(("cuckoo", "foo", "bar")) os.chdir(curdir)
def test_dist_migrate(self): with mock.patch("cuckoo.main.subprocess.check_call") as p: p.return_value = None main.main( ("--cwd", cwd(), "distributed", "migrate"), standalone_mode=False ) p.assert_called_once_with( ["alembic", "-x", "cwd=%s" % cwd(), "upgrade", "head"], cwd=cwd("distributed", "migration", private=True) )
def test_import_confirm(self, p, q, capsys): p.return_value = None q.return_value = True dirpath = tempfile.mkdtemp() main.main( ("--cwd", cwd(), "import", dirpath), standalone_mode=False ) p.assert_called_once_with(None, "copy", dirpath) out, err = capsys.readouterr() assert "understand that, depending on the mode" in out
def test_machine(self): with mock.patch("cuckoo.main.cuckoo_machine") as p: p.return_value = None main.main(( "--cwd", cwd(), "machine", "cuckoo2", "1.2.3.4", "--add" ), standalone_mode=False) p.assert_called_once_with( "cuckoo2", "add", "1.2.3.4", "windows", None, None, None, None, None )
def test_process_task(self, q, p1, p2): mkdir(cwd(analysis=1)) p1.return_value.view_task.return_value = {} main.main( ("--cwd", cwd(), "process", "-r", "1"), standalone_mode=False ) q.assert_called_once() p2.return_value.connect.assert_called_once() p1.return_value.connect.assert_not_called()
def test_import_cuckoo_cwd(capsys): set_cwd(tempfile.mkdtemp()) cuckoo_create() with pytest.raises(SystemExit): main.main( ("--cwd", cwd(), "import", cwd()), standalone_mode=False ) out, _ = capsys.readouterr() assert "import a legacy Cuckoo" in out
def test_cuckoo_init_kv_conf(self): filepath = Files.temp_put( "cuckoo.cuckoo.version_check = no" ) # Create a new CWD as Files.temp_put() indexes - or tries to - the # original cuckoo.conf (even though it doesn't exist yet). set_cwd(tempfile.mkdtemp()) with pytest.raises(SystemExit): main.main( ("--cwd", cwd(), "init", "--conf", filepath), standalone_mode=False ) assert config("cuckoo:cuckoo:version_check") is False
def test_cuckoo_init(self): """Tests that 'cuckoo init' works with a new CWD.""" with pytest.raises(SystemExit): main.main( ("--cwd", cwd(), "--nolog", "init"), standalone_mode=False ) assert os.path.exists(os.path.join(cwd(), "mitm.py")) assert os.path.exists(os.path.join(cwd(), "conf")) assert os.path.exists(os.path.join(cwd(), "storage")) assert os.path.exists(os.path.join(cwd(), "storage", "binaries")) assert os.path.exists(os.path.join(cwd(), "storage", "analyses")) assert os.path.exists(os.path.join(cwd(), "storage", "baseline")) assert os.path.exists(os.path.join(cwd(), "log"))
def test_process_tasks(self, q, p1, p2): p1.return_value.processing_get_task.side_effect = 1, 2 p1.return_value.view_task.side_effect = [ Task(id=1, category="url", target="http://google.com/"), Task(id=2, category="url", target="http://google.nl/"), ] main.main( ("--cwd", cwd(), "process", "p0"), standalone_mode=False ) assert q.call_count == 2 p2.return_value.connect.assert_called_once() p1.return_value.connect.assert_not_called()
def test_submit_unique_with_duplicates(p, q, capsys): set_cwd(tempfile.mkdtemp()) cuckoo_create() p.return_value = [ ("category", "target", 1), ("category", "target", None), ] main.main( ("--cwd", cwd(), "submit", "--unique", "a", "b"), standalone_mode=False ) out, err = capsys.readouterr() assert "added as task with" in out assert "Skipped" in out
def test_dnsserve_abort(self, p, capsys): p.side_effect = KeyboardInterrupt main.main(("--cwd", cwd(), "dnsserve"), standalone_mode=False) out, _ = capsys.readouterr() assert "Aborting Cuckoo DNS Serve" in out
def test_cuckoo_init_main(self): """Tests that 'cuckoo' works with a new CWD.""" main.main(("--cwd", cwd(), "--nolog"), standalone_mode=False) assert os.path.exists(os.path.join(cwd(), "stuff", "mitm.py"))
def test_process_init_modules(self, p, q): main.main( ("--cwd", cwd(), "process", "-r", "1"), standalone_mode=False ) p.assert_called_once()
def test_api(self): with mock.patch("cuckoo.main.cuckoo_api") as p: p.return_value = None main.main(("--cwd", cwd(), "api"), standalone_mode=False) p.assert_called_once_with("localhost", 8090, False)
def test_rooter_abort(self, p, capsys): p.side_effect = KeyboardInterrupt main.main(("--cwd", cwd(), "rooter"), standalone_mode=False) out, _ = capsys.readouterr() assert "Aborting the Cuckoo Rooter" in out
def test_community_abort(self, p, capsys): p.side_effect = KeyboardInterrupt main.main(("--cwd", cwd(), "community"), standalone_mode=False) out, _ = capsys.readouterr() assert "Aborting fetching of" in out
def test_clean(self): with mock.patch("cuckoo.main.cuckoo_clean") as p: p.return_value = None main.main(("--cwd", cwd(), "clean"), standalone_mode=False) p.assert_called_once_with()
def test_dnsserve(self): with mock.patch("cuckoo.main.cuckoo_dnsserve") as p: p.return_value = None main.main(("--cwd", cwd(), "dnsserve"), standalone_mode=False) p.assert_called_once_with("0.0.0.0", 53, None, None)
def test_cuckoo_init_main_nosigs(self, p): """Ensure load_signatures() isn't called for 'cuckoo' with new CWD.""" main.main(("--cwd", cwd(), "--nolog"), standalone_mode=False) assert os.path.exists(os.path.join(cwd(), "stuff", "mitm.py")) p.assert_not_called()
def migrate(cls): main.main(("--cwd", cwd(), "migrate"), standalone_mode=False)
def test_submit(self): with mock.patch("cuckoo.main.submit_tasks") as p: p.return_value = [] main.main(( "--cwd", cwd(), "submit", Files.create(cwd(), "a.txt", "hello") ), standalone_mode=False)
def test_clean_abort(self, p, capsys): p.side_effect = KeyboardInterrupt main.main(("--cwd", cwd(), "clean"), standalone_mode=False) out, _ = capsys.readouterr() assert "Aborting cleaning up of" in out