def test_publish_message(self): self.populate_file('main.yaml', '''--- variables: rabbit_config: server: 127.0.0.1:5671 virtualhost: catcher.virtual.host sslOptions: {'ssl_version': 'PROTOCOL_TLSv1_2', 'cert_reqs': 'CERT_NONE'} username: catcher password: catcher steps: - rabbit: publish: config: '{{ rabbit_config }}' exchange: 'catcher.test.exchange' routing_key: 'test' data: 'Catcher test message' headers: {'test.header.1': 'header1', 'test.header.2': 'header1'} name: 'publish message' ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) self.assertTrue(runner.run_tests()) import pika with pika.BlockingConnection(self.connectionParameters) as connection: channel = connection.channel() method_frame, header_frame, body = channel.basic_get(self.config['queue']) if method_frame: self.assertEqual(b'Catcher test message', body) self.assertEqual({'test.header.1': 'header1', 'test.header.2': 'header1'}, header_frame.headers) channel.basic_ack(method_frame.delivery_tag)
def test_populate_generate(self): self.populate_file('resources/pg_schema.sql', ''' CREATE TABLE foo( user_id integer primary key, email varchar(36) NOT NULL ); ''') self.populate_file('resources/foo.csv', "user_id,email\n" "{% for user in users %}" "{{ loop.index }},{{ user }}\n" "{% endfor %}" "4,other_email\n" ) self.populate_file('main.yaml', '''--- variables: postgres: 'test:test@localhost:5433/test' users: ['test_1', 'test_2', 'test_3'] steps: - prepare: populate: postgres: conf: '{{ postgres }}' schema: pg_schema.sql data: foo: foo.csv ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) self.assertTrue(runner.run_tests()) response = self.get_values('foo') self.assertEqual(4, len(response)) self.assertEqual(1, response[0][0]) self.assertEqual('test_1', response[0][1]) self.assertEqual('test_2', response[1][1]) self.assertEqual('test_3', response[2][1]) self.assertEqual('other_email', response[3][1])
def test_publish_json(self): self.populate_file('main.yaml', '''--- variables: rabbit_config: server: 127.0.0.1:5671 virtualhost: catcher.virtual.host sslOptions: {'ssl_version': 'PROTOCOL_TLSv1_2', 'cert_reqs': 'CERT_NONE'} username: catcher password: catcher steps: - rabbit: publish: config: '{{ rabbit_config }}' exchange: 'catcher.test.exchange' routing_key: 'test' data: "{{ {'key': RANDOM_INT}|tojson }}" headers: {'test.header.1': 'header1', 'test.header.2': 'header1'} name: 'publish message' ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) self.assertTrue(runner.run_tests()) import pika with pika.BlockingConnection(self.connectionParameters) as connection: channel = connection.channel() method_frame, header_frame, body = channel.basic_get(self.config['queue']) if method_frame: actual_test_data = json.loads(body.decode('UTF-8')) if not isinstance(actual_test_data["key"], numbers.Number): raise Exception('incorrect message format ' + str(actual_test_data)) channel.basic_ack(method_frame.delivery_tag)
def test_consume_message(self): # publish a message to the exchange so that it can be read by the queue import pika with pika.BlockingConnection(self.connectionParameters) as connection: channel = connection.channel() channel.basic_publish(exchange=self.config['exchange'], routing_key=self.config['routingKey'], body=b'Test queue message') self.populate_file('main.yaml', '''--- variables: rabbit_config: server: 127.0.0.1:5672 virtualhost: catcher.virtual.host username: catcher password: catcher steps: - rabbit: consume: config: '{{ rabbit_config }}' queue: 'catcher.test' register: {qMessage: '{{ OUTPUT }}'} name: 'consume message' - check: equals: {the: '{{ qMessage }}', is: 'Test queue message'} name: 'Check: consume message' ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) self.assertTrue(runner.run_tests())
def test_stop_from_include(self): self.populate_file('main.yaml', '''--- include: file: migration.yaml as: migrate variables: counter: 0 steps: - run: migrate - check: {equals: {the: '{{ counter }}', is: 2}} - run: migrate - check: {equals: {the: '{{ counter }}', is: 2}} ''') self.populate_file('migration.yaml', '''--- steps: - echo: {from: '{{ counter + 1 }}', register: {counter: '{{ OUTPUT }}'}} - stop: if: equals: '{{ counter > 1 }}' - echo: {from: '{{ counter + 1 }}', register: {counter: '{{ OUTPUT }}'}} - stop: if: equals: '{{ counter > 1 }}' - echo: {from: '{{ counter + 1 }}', register: {counter: '{{ OUTPUT }}'}} - check: {equals: {the: '{{ counter }}', is: 2}} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) self.assertTrue(runner.run_tests())
def test_write_lead(self, marketo_mock): instance = marketo_mock.return_value instance.execute.return_value = [{ 'status': 'updated' }, { 'status': 'updated' }] self.populate_file( 'main.yaml', '''--- variables: marketo_config: munchkin_id: test client_id: test client_secret: test email_1: '*****@*****.**' email_2: '*****@*****.**' steps: - marketo: write: conf: munchkin_id: '{{ marketo_munchkin_id }}' client_id: '{{ marketo_client_id }}' client_secret: '{{ marketo_client_secret }}' action: 'updateOnly' lookupField: 'custom_id' leads: - custom_id: 14 email: '{{ email_1 }}' custom_field_1: 'some value' - custom_id: 15 email: '{{ email_2 }}' custom_field_1: 'some other value' register: {response: '{{ OUTPUT }}'} - check: all: of: '{{ response }}' equals: {the: '{{ ITEM.status }}', is: 'updated'} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) self.assertTrue(runner.run_tests()) instance.execute.assert_called_with(method='create_update_leads', leads=[{ 'custom_id': 14, 'email': '*****@*****.**', 'custom_field_1': 'some value' }, { 'custom_id': 15, 'email': '*****@*****.**', 'custom_field_1': 'some other value' }], action='updateOnly', lookupField='custom_id', asyncProcessing='false', partitionName='Default')
def test_call_variables(self): TestClass.copy_resource(self, 'greeter.proto') self.populate_file( 'main.yaml', '''--- variables: data: result: url: 'my' title: 'test' snippets: 'test2' steps: - wait: seconds: 5 for: - grpc: call: url: 'localhost:50051' function: greeter.greet schema: 'greeter.proto' data: '{{ data }}' register: {value: '{{ OUTPUT.name }}'} - check: equals: {'the': '{{ value }}', 'is': 'Result for test contains test2'} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) self.assertTrue(runner.run_tests())
def test_different_conf(self): self.populate_file( 'test_inventory.yml', ''' postgres_str: 'test:test@localhost:5433/test' postgres_str_obj: url: 'test:test@localhost:5433/test' type: postgres postgres_obj: dbname: 'test' user: '******' password: '******' host: 'localhost' port: 5433 type: 'postgres' ''') self.populate_file( 'main.yaml', '''--- steps: - loop: foreach: in: '[{{ postgres_str_obj }}, "{{ postgres_str }}", {{ postgres_obj }}]' do: - postgres: request: conf: '{{ ITEM }}' query: 'select count(*) from test' register: {documents: '{{ OUTPUT }}'} - check: equals: {the: '{{ documents.count }}', is: 2} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), join(self.test_dir, 'test_inventory.yml')) self.assertTrue(runner.run_tests())
def test_read_simple_query(self): self.populate_file( 'test_inventory.yml', ''' postgres: dbname: test user: test password: test host: localhost port: 5433 ''') self.populate_file( 'main.yaml', '''--- steps: - postgres: request: conf: '{{ postgres }}' query: 'select count(*) from test' register: {documents: '{{ OUTPUT }}'} - check: equals: {the: '{{ documents.count }}', is: 2} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), join(self.test_dir, 'test_inventory.yml')) self.assertTrue(runner.run_tests())
def test_prepare_json(self): self.populate_file('resources/pg_schema.sql', ''' CREATE TABLE foo( user_id integer primary key, payload json NOT NULL ); ''') self.populate_file('resources/foo.csv', "user_id,payload\n" "1,{\"date\": \"1990-07-20\"}" ) self.populate_file('main.yaml', '''--- variables: postgres: 'test:test@localhost:5433/test' users: ['test_1', 'test_2', 'test_3'] steps: - prepare: populate: postgres: conf: '{{ postgres }}' schema: pg_schema.sql data: foo: foo.csv use_json: true - postgres: request: conf: '{{ postgres }}' query: "select payload ->> 'date' AS date from foo where user_id = 1" register: {date: '{{ OUTPUT.date }}' } - check: {equals: {the: '1990-07-20', is: '{{ date }}'}} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) self.assertTrue(runner.run_tests())
def test_loop_with_include(self): self.populate_file('main.yaml', '''--- include: file: print_file.yaml as: print variables: list: [{'file': 'a', 'value': 1}, {'file': 'b', 'value': 2}, {'file': 'c', 'value': 3}] steps: - loop: foreach: in: '{{ list }}' do: run: include: 'print' variables: data: '{{ ITEM["value"] }}' filename: '{{ ITEM["file"] }}' ''') self.populate_file('print_file.yaml', '''--- steps: - echo: {from: '{{ data }}', to: '{{ filename }}'} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) runner.run_tests() self.assertTrue(check_file(join(self.test_dir, 'a'), '1')) self.assertTrue(check_file(join(self.test_dir, 'b'), '2')) self.assertTrue(check_file(join(self.test_dir, 'c'), '3'))
def test_include_multiple_places(self): """ main |--> include1 --> include2 |--> include2 """ self.populate_file('main.yaml', '''--- include: - file: include1.yml as: inc1 - file: include2.yml as: inc2 ''') self.populate_file('include1.yml', '''--- include: - file: include2.yml as: inc2 ''') self.populate_file('include2.yml', '''--- variables: foo: 123 steps: - echo: {from: '{{ foo }}', to: other.output} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) self.assertTrue(runner.run_tests())
def test_run_from_template(self): self.populate_file( 'main.yaml', '''--- include: - file: one.yaml as: one - file: two.yaml as: two - file: determine_include.yaml as: determine_include steps: - run: 'determine_include' - run: '{{ include }}' ''') self.populate_file( 'one.yaml', '''--- steps: - echo: {from: 'bar', to: foo.output} ''') self.populate_file( 'two.yaml', '''--- steps: - echo: {from: 'baz', to: foo.output} ''') self.populate_file( 'determine_include.yaml', '''--- steps: - echo: {from: 'hello', register: {include: one}} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) runner.run_tests() self.assertTrue(check_file(join(self.test_dir, 'foo.output'), 'bar')) self.assertTrue(not os.path.exists(join(self.test_dir, 'baz.output')))
def test_populate_int(self): self.populate_file('resources/pg_schema.sql', ''' CREATE TABLE foo( user_id integer primary key, email varchar(36) NOT NULL ); ''') self.populate_file('resources/foo.csv', "user_id,email\n" "1,[email protected]\n" "2,[email protected]\n" ) self.populate_file('test_inventory.yml', ''' postgres: 'test:test@localhost:5433/test' ''') self.populate_file('main.yaml', '''--- steps: - prepare: populate: postgres: conf: '{{ postgres }}' schema: pg_schema.sql data: foo: foo.csv ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), join(self.test_dir, 'test_inventory.yml')) self.assertTrue(runner.run_tests()) response = self.get_values('foo') self.assertEqual(2, len(response)) self.assertEqual(1, response[0][0]) self.assertEqual('*****@*****.**', response[0][1]) self.assertEqual(2, response[1][0]) self.assertEqual('*****@*****.**', response[1][1])
def test_register_run_tags_with_dot(self): self.populate_file( 'main.yaml', '''--- include: file: simple_file.yaml as: simple.with_dot steps: - run: include: 'simple.with_dot.one' ''') self.populate_file( 'simple_file.yaml', '''--- variables: foo: 1 baz: 2 bar: 3 steps: - echo: {from: '{{ foo }}', to: foo.output, tag: one} - echo: {from: '{{ baz }}', to: baz.output} - echo: {from: '{{ bar }}', to: bar.output, tag: one} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) runner.run_tests() self.assertTrue(check_file(join(self.test_dir, 'foo.output'), '1')) self.assertTrue(not os.path.exists(join(self.test_dir, 'baz.output'))) self.assertTrue(check_file(join(self.test_dir, 'bar.output'), '3'))
def test_compose(self): self.populate_resource('docker-compose.yml', ''' version: '3.1' services: mockserver: image: jamesdbloom/mockserver ports: - "8000:1080" ''') self.populate_file('main.yaml', '''--- steps: - wait: seconds: 5 for: http: put: url: 'http://localhost:8000/mockserver/expectation' body: httpRequest: {'path': '/some/path'} httpResponse: {'body': 'hello world'} response_code: 201 - http: get: url: 'http://localhost:8000/mockserver/expectation', response_code: 200 ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None, resources=join(test.get_test_dir(self.test_name), 'resources')) self.assertFalse(runner.run_tests())
def test_cmd_override_all(self): self.populate_file( 'inventory.yml', '''--- foo2: baz ''') self.populate_file( 'main.yaml', '''--- variables: foo: baz steps: - echo: actions: - {from: '{{ foo }}', to: one.output} - {from: '{{ foo2 }}', to: two.output} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), join(self.test_dir, 'inventory.yml'), cmd_env={ 'foo': 'bad', 'foo2': 'bad' }) runner.run_tests() self.assertTrue(check_file(join(self.test_dir, 'one.output'), 'bad')) self.assertTrue(check_file(join(self.test_dir, 'two.output'), 'bad'))
def test_var_in_run_as_obj(self): self.populate_resource( 'test.csv', "email,id\n" "{%- for user in users %}\n" "{{ user.email }},{{ user.id }}\n" "{%- endfor -%}") self.populate_file( 'main.yaml', '''--- variables: users: - email: '*****@*****.**' id: 1 - email: '*****@*****.**' id: 2 include: file: one.yaml as: one steps: - run: include: 'one' variables: users: '{{ users[:1] }}' ''') self.populate_file( 'one.yaml', '''--- steps: - echo: {from_file: 'test.csv', to: res.output} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) runner.run_tests() self.assertTrue( check_file(join(self.test_dir, 'res.output'), 'email,id\[email protected],1'))
def test_populate_sql(self): self.populate_file( 'resources/schema.sql', ''' CREATE TABLE if not exists foo( user_id integer primary key, email varchar(36) NOT NULL ); {%- for user in users %} insert into foo values ({{user.num}}, '{{user.email}}'); {%- endfor -%} ''') self.populate_file( 'main.yaml', '''--- variables: users: - num: 1 email: [email protected] - num: 2 email: [email protected] steps: - postgres: request: conf: 'test:test@localhost:5433/test' sql: schema.sql ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) self.assertTrue(runner.run_tests()) response = self.get_values('foo') self.assertEqual([(1, '*****@*****.**'), (2, '*****@*****.**')], response)
def run_tests(path: str, arguments: dict): file_or_dir = arguments['<tests>'] inventory = arguments['--inventory'] environment = arguments['--environment'] modules = arguments['--modules'] resources = arguments['--resources'] output_format = arguments['--format'] filters = arguments['--filter'] use_sys_vars = arguments['--system_env'] output = 'full' if not arguments['--q'] else 'limited' if arguments['--qq']: output = 'final' if strtobool(use_sys_vars): sys_vars = dict(os.environ) else: sys_vars = None __load_modules(modules) runner = Runner(path, file_or_dir, inventory, modules=modules, cmd_env=__env_to_variables(environment), resources=resources, system_environment=sys_vars, output_format=output_format, filter_list=filters) return runner.run_tests(output=output)
def test_run_tagged_tagged(self): self.populate_file( 'main.yaml', '''--- include: file: one.yaml as: one steps: - run: 'one.before' ''') self.populate_file( 'one.yaml', '''--- include: file: two.yaml as: two steps: - run: include: two.one tag: before - echo: {from: '{{ bar }}', to: after.output, tag: after} ''') self.populate_file( 'two.yaml', '''--- steps: - echo: {from: '1', to: foo.output, tag: one} - echo: {from: '2', to: baz.output, tag: two} - echo: {from: '3', to: bar.output, tag: three} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) runner.run_tests() self.assertTrue(check_file(join(self.test_dir, 'foo.output'), '1')) self.assertTrue(not os.path.exists(join(self.test_dir, 'baz.output'))) self.assertTrue(not os.path.exists(join(self.test_dir, 'bar.output')))
def test_computed_equals_constant(self): self.populate_file('main.yaml', '''--- steps: - echo: {from: 'hello', register: {'foo': 'value'}} - check: {equals: {the: '{{ foo }}', is: 'value'}} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) self.assertTrue(runner.run_tests())
def test_compate_dates(self): self.populate_file('main.yaml', '''--- steps: - check: equals: {the: '2020-03-11', is_not: '2020-11-03' } ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) self.assertTrue(runner.run_tests())
def test_no_compose(self, m): m.get('http://test.com', status_code=500) self.populate_file('main.yaml', '''--- steps: - http: {get: {url: 'http://test.com', response_code: 200}} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) self.assertFalse(runner.run_tests())
def test_check_short_form(self): self.populate_file('main.yaml', '''--- variables: foo: true steps: - check: '{{ foo }}' ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) self.assertTrue(runner.run_tests())
def test_random_functions(self): Faker.seed(4321) self.populate_file('main.yaml', '''--- steps: - echo: {from: '{{ random("ipv4_private") }}', to: one.output} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) self.assertTrue(runner.run_tests()) self.assertTrue(check_file(join(self.test_dir, 'one.output'), '10.32.135.245'))
def test_run_ignore_test(self): self.populate_file( 'main.yaml', '''--- ignore: true # for some reason this test is not working steps: - check: {equals: {the: true, is: false}} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) self.assertTrue(runner.run_tests())
def test_run_one_action(self): self.populate_file( 'main.yaml', '''--- steps: - echo: {from: 'test', to: main.output} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) runner.run_tests() self.assertTrue(check_file(join(self.test_dir, 'main.output'), 'test'))
def test_await_range_xx(self, m): m.get('http://test.com', status_code=201) self.populate_file( 'main.yaml', '''--- steps: - http: {get: {url: 'http://test.com', response_code: 2xx-3xx}} ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), None) self.assertTrue(runner.run_tests())
def test_populate_from_scratch(self): self.populate_file('resources/pg_schema.sql', ''' CREATE TABLE foo( user_id varchar(36) primary key, email varchar(36) NOT NULL ); CREATE TABLE bar( key varchar(36) primary key, value varchar(36) NOT NULL ); ''') self.populate_file('resources/foo.csv', "user_id,email\n" "1,[email protected]\n" "2,[email protected]\n" ) self.populate_file('resources/bar.csv', "key,value\n" "k1,v1\n" "k2,v2\n" ) self.populate_file('test_inventory.yml', ''' postgres: dbname: test user: test password: test host: localhost port: 5433 ''') self.populate_file('main.yaml', '''--- steps: - prepare: populate: postgres: conf: '{{ postgres }}' schema: pg_schema.sql data: foo: foo.csv bar: bar.csv ''') runner = Runner(self.test_dir, join(self.test_dir, 'main.yaml'), join(self.test_dir, 'test_inventory.yml')) self.assertTrue(runner.run_tests()) response = self.get_values('foo') self.assertEqual(2, len(response)) self.assertEqual('1', response[0][0]) self.assertEqual('*****@*****.**', response[0][1]) self.assertEqual('2', response[1][0]) self.assertEqual('*****@*****.**', response[1][1]) response = self.get_values('bar') self.assertEqual(2, len(response)) self.assertEqual('k1', response[0][0]) self.assertEqual('v1', response[0][1]) self.assertEqual('k2', response[1][0]) self.assertEqual('v2', response[1][1])