def test_add_n(): res = execute_solid( add_n, input_values={"x": 3}, run_config={"solids": {"add_n": {"config": 7}}} ) assert res.output_value() == 10
def test_dict_return_solid(): res = execute_solid(dict_return_solid) assert res.output_value() == {'foo': 'bar'}
def test_cache_file_from_s3_overwrite(): with get_temp_dir() as temp_dir: s3_session_one = mock.MagicMock() execute_solid( cache_file_from_s3, ModeDefinition( resource_defs={ 'file_cache': fs_file_cache, 's3': ResourceDefinition.hardcoded_resource( s3_session_one), }), environment_dict={ 'solids': { 'cache_file_from_s3': { 'inputs': { 's3_coordinate': { 'bucket': 'some-bucket', 'key': 'some-key' } } } }, 'resources': { 'file_cache': { 'config': { 'target_folder': temp_dir, 'overwrite': True } } }, }, ) # assert the download occurred assert s3_session_one.download_file.call_count == 1 s3_session_two = mock.MagicMock() execute_solid( cache_file_from_s3, ModeDefinition( resource_defs={ 'file_cache': fs_file_cache, 's3': ResourceDefinition.hardcoded_resource( s3_session_two), }), environment_dict={ 'solids': { 'cache_file_from_s3': { 'inputs': { 's3_coordinate': { 'bucket': 'some-bucket', 'key': 'some-key' } } } }, 'resources': { 'file_cache': { 'config': { 'target_folder': temp_dir, 'overwrite': True } } }, }, ) # assert the download did not occur because file is already there assert s3_session_two.download_file.call_count == 0
def test_nullable_concat(): res = execute_solid(nullable_concat, input_values={'x': 'foo', 'y': None}) assert res.output_value() == 'foo'
def test_set_solid(): res = execute_solid(set_solid, input_values={'set_input': {'foo', 'bar', 'baz'}}) assert res.output_value() == sorted(['foo', 'bar', 'baz'])
def test_add_3(): res = execute_solid(add_3, input_values={'x': 3}) assert res.output_value() == 6
def test_concat(): res = execute_solid(concat, input_values={'x': 'foo', 'y': 'bar'}) assert res.output_value() == 'foobar'
def test_failure_metadata_solid(): with pytest.raises(Failure): execute_solid(my_failure_metadata_solid)
def test_two_list_types(): @solid( input_defs=[], config={ 'list_one': [int], 'list_two': [int] }, ) def two_list_type(context): return context.solid_config assert execute_solid( two_list_type, environment_dict={ 'solids': { 'two_list_type': { 'config': { 'list_one': [1], 'list_two': [2] } } } }, ).output_value() == { 'list_one': [1], 'list_two': [2] } @solid( input_defs=[], config={ 'list_one': [Int], 'list_two': [Int] }, ) def two_list_type_condensed_syntax(context): return context.solid_config assert execute_solid( two_list_type_condensed_syntax, environment_dict={ 'solids': { 'two_list_type_condensed_syntax': { 'config': { 'list_one': [1], 'list_two': [2] } } } }, ).output_value() == { 'list_one': [1], 'list_two': [2] } @solid( input_defs=[], config={ 'list_one': [int], 'list_two': [int] }, ) def two_list_type_condensed_syntax_primitives(context): return context.solid_config assert execute_solid( two_list_type_condensed_syntax_primitives, environment_dict={ 'solids': { 'two_list_type_condensed_syntax_primitives': { 'config': { 'list_one': [1], 'list_two': [2] } } } }, ).output_value() == { 'list_one': [1], 'list_two': [2] }
def test_repeat_config(): res = execute_solid( repeat_config, run_config={"solids": {"repeat_config": {"config": {"word": "foo", "times": 3}}}}, ) assert res.output_value() == "foofoofoo"
def test_selector_config(): res = execute_solid( hello_world, run_config={"solids": {"hello_world": {"config": {"haw": {}}}}} ) assert res.output_value() == "Aloha honua!"
def test_concat_typeless_config(): res = execute_solid( concat_typeless_list_config, run_config={"solids": {"concat_typeless_list_config": {"config": ["foo", "bar", "baz"]}}}, ) assert res.output_value() == "foobarbaz"
def test_hello(): res = execute_solid(hello, run_config={"solids": {"hello": {"config": "Max"}}}) assert res.output_value() == "Hello, Max!"
def test_div_y(): res = execute_solid( div_y, input_values={"x": 3.0}, run_config={"solids": {"div_y": {"config": 2.0}}} ) assert res.output_value() == 1.5
def test_boolean(): res = execute_solid(boolean, input_values={'x': True}) assert res.output_value() == 'true' res = execute_solid(boolean, input_values={'x': False}) assert res.output_value() == 'false'
def test_python_tuple_output(): @lambda_solid def emit_tuple() -> tuple: return (4, 5) assert execute_solid(emit_tuple).output_value() == (4, 5)
def test_empty_string(): res = execute_solid(empty_string, input_values={'x': ''}) assert res.output_value() is True res = execute_solid(empty_string, input_values={'x': 'foo'}) assert res.output_value() is False
def test_open_typing_tuple_output(): @lambda_solid(output_def=OutputDefinition(Tuple)) def emit_tuple(): return (1, 2) assert execute_solid(emit_tuple).output_value() == (1, 2)
def test_div_2(): res = execute_solid(div_2, input_values={'x': 7.0}) assert res.output_value() == 3.5
def test_complicated_dictionary_typing_pass(): @lambda_solid(output_def=OutputDefinition(typing.Dict[str, typing.List[typing.Dict[int, int]]])) def emit_dict(): return {"foo": [{1: 1, 2: 2}]} assert execute_solid(emit_dict).output_value() == {"foo": [{1: 1, 2: 2}]}
def test_exists(): res = execute_solid(exists, input_values={'path': 'garkjgh.dkjhfk'}) assert res.output_value() is False
def test_dagster_dictionary_output(): @lambda_solid(output_def=OutputDefinition(dict)) def emit_dict(): return {"key": "value"} assert execute_solid(emit_dict).output_value() == {"key": "value"}
def test_concat_list(): res = execute_solid(concat_list, input_values={'xs': ['foo', 'bar', 'baz']}) assert res.output_value() == 'foobarbaz'
def test_basic_typing_dictionary_output(): @lambda_solid(output_def=OutputDefinition(typing.Dict)) def emit_dict(): return {"key": "value"} assert execute_solid(emit_dict).output_value() == {"key": "value"}
def test_tuple_solid(): res = execute_solid(tuple_solid, input_values={'tuple_input': ('foo', 1, 3.1)}) assert res.output_value() == ['foo', 1, 3.1]
def test_kitchen_sink(): @solid( config_schema={ "str_field": str, "int_field": int, "list_int": [int], "list_list_int": [[int]], "dict_field": { "a_string": str }, "list_dict_field": [{ "an_int": int }], "selector_of_things": Selector({ "select_list_dict_field": [{ "an_int": int }], "select_int": int }), # this is a good argument to use () instead of [] for type parameterization in # the config system "optional_list_of_optional_string": Noneable([Noneable(str)]), }) def kitchen_sink(context): return context.solid_config solid_config_one = { "str_field": "kjf", "int_field": 2, "list_int": [3], "list_list_int": [[1], [2, 3]], "dict_field": { "a_string": "kdjfkd" }, "list_dict_field": [{ "an_int": 2 }, { "an_int": 4 }], "selector_of_things": { "select_int": 3 }, "optional_list_of_optional_string": ["foo", None], } assert (execute_solid( kitchen_sink, run_config={ "solids": { "kitchen_sink": { "config": solid_config_one } } }, ).output_value() == solid_config_one) solid_config_two = { "str_field": "kjf", "int_field": 2, "list_int": [3], "list_list_int": [[1], [2, 3]], "dict_field": { "a_string": "kdjfkd" }, "list_dict_field": [{ "an_int": 2 }, { "an_int": 4 }], "selector_of_things": { "select_list_dict_field": [{ "an_int": 5 }] }, "optional_list_of_optional_string": None, } assert (execute_solid( kitchen_sink, run_config={ "solids": { "kitchen_sink": { "config": solid_config_two } } }, ).output_value() == solid_config_two)
def test_open_typing_set_output(): @lambda_solid(output_def=OutputDefinition(typing.Set)) def emit_set(): return {1, 2} assert execute_solid(emit_set).output_value() == {1, 2}
def test_identity_imp(): res = execute_solid(identity_imp, input_values={'x': 'foo'}) assert res.output_value() == 'foo'
def test_datadog_resource( event, gauge, increment, decrement, histogram, distribution, statsd_set, service_check, timed, timing, ): @solid def datadog_solid(context): assert context.resources.datadog # event context.resources.datadog.event('Man down!', 'This server needs assistance.') event.assert_called_with('Man down!', 'This server needs assistance.') # gauge context.resources.datadog.gauge('users.online', 1001, tags=["protocol:http"]) gauge.assert_called_with('users.online', 1001, tags=["protocol:http"]) # increment context.resources.datadog.increment('page.views') increment.assert_called_with('page.views') # decrement context.resources.datadog.decrement('page.views') decrement.assert_called_with('page.views') context.resources.datadog.histogram('album.photo.count', 26, tags=["gender:female"]) histogram.assert_called_with('album.photo.count', 26, tags=["gender:female"]) context.resources.datadog.distribution('album.photo.count', 26, tags=["color:blue"]) distribution.assert_called_with('album.photo.count', 26, tags=["color:blue"]) context.resources.datadog.set('visitors.uniques', 999, tags=["browser:ie"]) statsd_set.assert_called_with('visitors.uniques', 999, tags=["browser:ie"]) context.resources.datadog.service_check( 'svc.check_name', context.resources.datadog.WARNING) service_check.assert_called_with('svc.check_name', context.resources.datadog.WARNING) context.resources.datadog.timing("query.response.time", 1234) timing.assert_called_with("query.response.time", 1234) @context.resources.datadog.timed('run_fn') def run_fn(): pass run_fn() timed.assert_called_with('run_fn') result = execute_solid( datadog_solid, environment_dict={ 'resources': { 'datadog': { 'config': { 'api_key': 'NOT_USED', 'app_key': 'NOT_USED' } } } }, mode_def=ModeDefinition(resource_defs={'datadog': datadog_resource}), ) assert result.success
def test_bool_config(): res = execute_solid(bool_config, run_config={"solids": {"bool_config": {"config": True}}}) assert res.output_value() == "true" res = execute_solid(bool_config, run_config={"solids": {"bool_config": {"config": False}}}) assert res.output_value() == "false"