init

Author: ArthurSrz

features/ascent_complexity.feature

@@ -0,0 +1,26 @@
+Feature: complexity ascent
+  Feature that reaugment the complexity order of the data
+
+  Rule: Reuse type as ultimate target
+    One complexity order relates to one reuse type.
+    When the complexity order reached by the user meets reuse type targeted by the user
+    then the data redesign method has fulfilled its mission
+  
+  Rule: Graphic interactions
+    Complexity ascent can only happen through graphic interactions
+    with clear and distinct entites, attributes and entities.
+
+  Scenario: complexity ascent
+    Given feature
+    * memory worked
+    * tidy data worked
+    * one day at least passed since the last complexity descent 
+    * user reached the lowest complexity order
+    When the user asks for complexity ascent
+    Then he gets an appointment with the data expert
+    Then the expert he will play the role of a copilot
+    When users agrees
+    Then he is showed complexity ascent tolls
+    When the user is done using one tool 
+    Then the expert/copilot evaluate the new complexity order 
+    Then he shows the user reuses option now available 

features/complexity_descent.feature

@@ -0,0 +1,26 @@
+Feature: get down from upper to lower complexity order
+  The user wants to reuse a dataset to create a new indicator. 
+  The user found out that the complexity order of the datasets is 3. 
+  He wants to lower the complexity order to 2, so he gets in touch with a data expert. 
+  He meets the expert and at the end of the process, the complexity order of the dataset is 2.
+
+  Rule: One user, one expert
+    One user can only be in touch with one expert throughout the whole process.
+  
+  Scenario: complexity descent
+    Given the user used the measure complexity feature
+    When the user wants to lower the complexity order of the dataset
+    Then he gets in touch with a data expert
+    When the appointment starts
+    Then the expert asks the user what indicator he wants to create
+    When the user answers
+    Then the expert asks the user what dataset he wants to use
+    When the user answers
+    Then the expert asks the user what complexity order he wants to reach
+    When the user answers
+    Then the expert begins the process of lowering the complexity order
+    When the process is over
+    Then the complexity order of the dataset is lowered
+    Then he explains what the user can do with such complexity order 
+    Then the appointment ends
+

features/measure_complexity.feature

@@ -0,0 +1,12 @@
+Feature: measure dataset complexity order
+  The user wants to know how complex the datasets he intends to use are. 
+  The feature will give the user an approximation of such complexity 
+  by displaying the complexity order of the data.
+
+  Rule: One dataset, one measure, one reuse
+    The user can only measure the complexity of one dataset at a time.
+  
+  Scenario: measure complexity order of a dataset
+    Given the user has a dataset
+    When the user asks for the complexity order of the dataset
+    Then the user will be given the complexity order of the dataset 

features/memory.feature

@@ -0,0 +1,12 @@
+Feature: complexity memory
+  The system remembers the variable, entity and value cast aside 
+  during the complexity descent process.
+
+  Rule: Simplification, not oblivion
+    Data complexity is not obliviated during the complexity descent process
+    but simplified, which means it is just taking new shape. 
+  
+  Scenario: keep entity, variable and value deleted in memory
+    When the expert deletes an entity, variable or value
+    Then the system remembers the deleted entity, variable or value
+    And the system shows the deleted entity, variable or value to the user 

features/steps/complexity_ascent.py

@@ -0,0 +1,84 @@
+from behave import given, when, then
+
+class Context:
+    def __init__(self):
+        self.memory_worked = False
+        self.tidy_data_worked = False
+        self.passed_one_day = False
+        self.user_reached_lowest_complexity = False
+        self.user_asks_for_ascent = False
+        self.appointment_scheduled = False
+        self.copilot_role_set = False
+        self.user_agrees = False
+        self.tools_shown = False
+        self.tool_used = False
+        self.new_complexity_evaluated = False
+        self.reuses_shown = False
+
+context = Context()
+
+# Given steps
+@given("feature")
+def step_feature(context):
+    pass
+
+@given("memory worked")
+def step_memory_worked(context):
+    context.memory_worked = True
+
+@given("tidy data worked")
+def step_tidy_data_worked(context):
+    context.tidy_data_worked = True
+
+@given("one day at least passed since the last complexity descent")
+def step_passed_one_day(context):
+    context.passed_one_day = True
+
+@given("user reached the lowest complexity order")
+def step_user_reached_lowest_complexity(context):
+    context.user_reached_lowest_complexity = True
+
+# When steps
+@when("the user asks for complexity ascent")
+def step_user_asks_for_ascent(context):
+    context.user_asks_for_ascent = True
+
+@when("users agrees")
+def step_users_agrees(context):
+    context.user_agrees = True
+
+@when("the user is done using one tool")
+def step_user_done_using_tool(context):
+    context.tool_used = True
+
+# Then steps
+@then("he gets an appointment with the data expert")
+def step_get_appointment_with_expert(context):
+    assert context.memory_worked, "Memory feature didn't work"
+    assert context.tidy_data_worked, "Tidy data feature didn't work"
+    assert context.passed_one_day, "Not enough time has passed since last descent"
+    assert context.user_reached_lowest_complexity, "User hasn't reached lowest complexity"
+    assert context.user_asks_for_ascent, "User didn't ask for ascent"
+    context.appointment_scheduled = True
+
+@then("the expert he will play the role of a copilot")
+def step_expert_plays_copilot_role(context):
+    assert context.appointment_scheduled, "Appointment not scheduled"
+    context.copilot_role_set = True
+
+@then("he is showed complexity ascent tools")
+def step_show_ascent_tools(context):
+    assert context.copilot_role_set, "Copilot role not set"
+    assert context.user_agrees, "User didn't agree"
+    context.tools_shown = True
+
+@then("the expert/copilot evaluate the new complexity order")
+def step_evaluate_new_complexity(context):
+    assert context.tools_shown, "Tools not shown"
+    assert context.tool_used, "User didn't use tool"
+    context.new_complexity_evaluated = True
+
+@then("he shows the user reuses option now available")
+def step_show_available_reuses(context):
+    assert context.new_complexity_evaluated, "Complexity not evaluated"
+    context.reuses_shown = True

features/steps/complexity_memory.py

@@ -0,0 +1,28 @@
+from behave import given, when, then
+
+class Context:
+    def __init__(self):
+        self.expert_action = None
+        self.deleted_item = None
+        self.system_memory = []
+        self.deleted_item_shown = False
+
+context = Context()
+
+# When steps
+@when("the expert deletes an entity, variable or value")
+def step_expert_deletes_entity_variable_value(context):
+    context.expert_action = "delete"
+
+# Then steps
+@then("the system remembers the deleted entity, variable or value")
+def step_system_remembers_deleted_item(context):
+    assert context.expert_action == "delete", "Expert action not set"
+    context.deleted_item = "example_deleted_item"  # Replace with actual deleted item
+    context.system_memory.append(context.deleted_item)
+
+@then("the system shows the deleted entity, variable or value to the user")
+def step_system_shows_deleted_item_to_user(context):
+    assert context.deleted_item, "Deleted item not remembered"
+    assert context.deleted_item in context.system_memory, "Deleted item not in memory"
+    context.deleted_item_shown = True

features/steps/descent_complexity.py

@@ -0,0 +1,82 @@
+from behave import given, when, then
+
+class Context:
+    def __init__(self):
+        self.feature_used = False
+        self.lower_complexity = False
+        self.appointment_started = False
+        self.user_answered_indicator = False
+        self.user_answered_dataset = False
+        self.user_answered_order = False
+        self.process_started = False
+        self.process_completed = False
+        self.explanation_given = False
+
+context = Context()
+
+# Given steps
+@given("the user used the measure complexity feature")
+def step_user_used_measure_complexity_feature(context):
+    context.feature_used = True
+
+# When steps
+@when("the user wants to lower the complexity order of the dataset")
+def step_user_wants_to_lower_complexity_order(context):
+    context.lower_complexity = True
+
+@when("the appointment starts")
+def step_appointment_starts(context):
+    context.appointment_started = True
+
+@when("the user answers")
+def step_user_answers(context):
+    if "what indicator" in context.active_step.text:
+        context.user_answered_indicator = True
+    elif "what dataset" in context.active_step.text:
+        context.user_answered_dataset = True
+    elif "what complexity order" in context.active_step.text:
+        context.user_answered_order = True
+
+@when("the expert begins the process of lowering the complexity order")
+def step_expert_begins_lowering_complexity(context):
+    assert context.appointment_started, "Appointment hasn't started"
+    assert context.user_answered_indicator, "User didn't answer indicator question"
+    assert context.user_answered_dataset, "User didn't answer dataset question"
+    assert context.user_answered_order, "User didn't answer complexity order question"
+    context.process_started = True
+
+@when("the process is over")
+def step_process_is_over(context):
+    assert context.process_started, "Process hasn't started"
+    context.process_completed = True
+
+@when("he explains what the user can do with such complexity order")
+def step_explain_user_capabilities(context):
+    assert context.process_completed, "Process isn't completed"
+    context.explanation_given = True
+
+# Then steps
+@then("he gets in touch with a data expert")
+def step_user_gets_in_touch_with_data_expert(context):
+    assert context.feature_used, "User didn't use the feature"
+
+@then("the expert asks the user what indicator he wants to create")
+def step_expert_asks_user_about_indicator(context):
+    assert context.appointment_started, "Appointment hasn't started"
+
+@then("the expert asks the user what dataset he wants to use")
+def step_expert_asks_user_about_dataset(context):
+    assert context.user_answered_indicator, "User didn't answer indicator question"
+
+@then("the expert asks the user what complexity order he wants to reach")
+def step_expert_asks_user_about_complexity_order(context):
+    assert context.user_answered_dataset, "User didn't answer dataset question"
+
+@then("the complexity order of the dataset is lowered")
+def step_complexity_order_lowered(context):
+    assert context.process_completed, "Process isn't completed"
+
+@then("he explains what the user can do with such complexity order")
+def step_explain_user_capabilities(context):
+    assert context.explanation_given, "Explanation not given"
+

features/steps/measure_complexity.py

@@ -0,0 +1,22 @@
+from behave import given, when, then
+
+@given("the user has a dataset")
+def step_user_has_dataset(context):
+    # You can set up the dataset here, if needed
+    context.dataset = ...
+
+@when("the user asks for the complexity order of the dataset")
+def step_user_asks_for_complexity_order(context):
+    # Perform the action to calculate the complexity order of the dataset
+    context.complexity_order = calculate_complexity_order(context.dataset)
+
+@then("the user will be given the complexity order of the dataset")
+def step_user_given_complexity_order(context):
+    expected_complexity_order = ...
+    assert context.complexity_order == expected_complexity_order, \
+        f"Expected complexity order: {expected_complexity_order}, Actual complexity order: {context.complexity_order}"
+
+# You can define the calculate_complexity_order function here
+def calculate_complexity_order(dataset):
+    # Implement the logic to calculate the complexity order
+    ...

features/steps/tidy_data.py

@@ -0,0 +1,33 @@
+from behave import given, when, then
+
+class Context:
+    def __init__(self):
+        self.complexity_memory_feature_worked = False
+        self.messy_data = None
+        self.tidy_tables = None
+        self.icon_displayed = False
+
+context = Context()
+
+# Given steps
+@given("complexity memory feature worked")
+def step_complexity_memory_feature_worked(context):
+    context.complexity_memory_feature_worked = True
+
+# When steps
+@when("the user uses the system")
+def step_user_uses_the_system(context):
+    assert context.complexity_memory_feature_worked, "Complexity memory feature didn't work"
+    context.messy_data = []  # Define the messy data here
+
+@then("the system retrieves the messy data")
+def step_system_retrieves_messy_data(context, table):
+    context.messy_data = table
+
+@then("turns it into a tidy format")
+def step_turns_into_tidy_format(context, *tables):
+    context.tidy_tables = tables
+
+@then("the user sees an icon showing when the state of the data tidying process")
+def step_user_sees_icon_display(context):
+    context.icon_displayed = True

features/tidy_data.feature

@@ -0,0 +1,49 @@
+Feature: tidy data
+  Feature that turns messy data cast aside during
+  the complexity descent process into tidy data.
+
+  Scenario: tidy data cast aside
+    Given complexity memory feature worked
+    When the users uses the system
+    Then the system retrieves the messy data
+
+    | Entity       | Attribute | Value        | Order ID | Product Name | Quantity | Total Amount | Method   | Address     | Method      | Amount     |
+    | Customer     | Name      | John         |          |              |          |              |          |             |             |            |
+    |              | Phone     | 555-123-4567 |          |              |          |              |          |             |             |            |
+    |              | Address   | 123 Main St  |          |              |          |              |          |             |             |            |
+    | Order        |           |              | 987654   |              |          |              |          |             |             |            |
+    |              |           |              |          | Widget       |          |              |          |             |             |            |
+    |              |           |              |          |              | 3        |              |          |             |             |            |
+    |              |           |              |          |              |          | $150.00      |          |             |             |            |
+    | Shipping     |           |              |          |              |          |              | Express  |             |             |            |
+    |              |           |              |          |              |          |              |          | 456 Elm St |             |            |
+    | Payment      |           |              |          |              |          |              |          |             | Credit Card |            |
+    |              |           |              |          |              |          |              |          |             |             | $150.00    |
+
+    
+    Then turns it into a tidy format 
+
+    |   Entity   |     Attribute     |      Value      |
+    |  Customer  |       Name        |      John       |
+    |  Customer  |   Phone Number    |   555-123-4567  |
+    |  Customer  |   Address         |   123 Main St   |
+
+
+    |  Entity  |   Attribute    |   Value    |
+    |  Order   |   Order ID     |   987654   |
+    |  Order   |  Product Name  |   Widget   |
+    |  Order   |   Quantity     |     3      |
+    |  Order   |  Total Amount  |  $150.00   |
+
+
+    |  Entity   |  Attribute  |    Value    |
+    |  Shipping |   Method    |   Express   |
+    |  Shipping |   Address   |  456 Elm St |
+
+
+    |  Entity  |  Attribute   |     Value    |
+    |  Payment |   Method     |  Credit Card |
+    |  Payment |   Amount     |     $150.00  |
+
+
+    And the user sees an icon showing when the state of the data tidying process