hydra_attribute 0.4.2 → 0.5.0.rc1

data/features/relation/query_methods/order.feature

@@ -1,67 +0,0 @@
-Feature: order conditions by hydra attributes
-  When order records by hydra attribute
-  Then correct table should be joined and order by value should be added
-
-  When correct table is already joined
-  Then only order condition should be added
-
-  When order by several attributes
-  Then order all of them by ascending
-
-  Background: create hydra attributes
-    Given create hydra attributes for "Product" with role "admin" as "hashes":
-      | name  | backend_type | white_list |
-      | code  | integer      | [bool:t]   |
-      | state | integer      | [bool:t]   |
-      | title | string       | [bool:t]   |
-
-  Scenario Outline: order by one field
-    Given create "Product" model with attributes as "hashes":
-      | name | code | state |
-      | c    | 1    | 1     |
-      | b    | 2    | 2     |
-      | a    | 3    | 3     |
-    When order "Product" records by "<attributes>"
-    Then "first" record should have "<first identifier>"
-    And "last" record should have "<last identifier>"
-
-    Scenarios: order conditions
-      | attributes | first identifier | last identifier |
-      | state=asc  | code=[int:1]     | code=[int:3]    |
-      | state=desc | code=[int:3]     | code=[int:1]    |
-      | name=asc   | code=[int:3]     | code=[int:1]    |
-      | name=desc  | code=[int:1]     | code=[int:3]    |
-
-  Scenario Outline: order by several attributes
-    Given create "Product" model with attributes as "hashes":
-      | name | code | state | title |
-      | c    | 1    | 1     | b     |
-      | b    | 2    | 2     | a     |
-      | a    | 3    | 3     | c     |
-    When order "Product" records by "<attributes>"
-    Then "first" record should have "<first identifier>"
-    And "last" record should have "<last identifier>"
-
-    Scenarios: order conditions
-      | attributes  | first identifier | last identifier |
-      | name state  | code=[int:3]     | code=[int:1]    |
-      | state title | code=[int:1]     | code=[int:3]    |
-      | title state | code=[int:2]     | code=[int:3]    |
-
-  Scenario Outline: order by filtered attribute
-    Given create "Product" model with attributes as "hashes":
-      | code | state | title |
-      | 1    | 1     |       |
-      | 2    |       |       |
-      | 3    | 1     | a     |
-    When filter "Product" records by "<filter attribute>"
-    And order records by "<order attributes>"
-    Then total records should be "<count>"
-    And "first" record should have "<first identifier>"
-    And "last" record should have "<last identifier>"
-
-    Scenarios: order conditions
-      | filter attribute | order attributes | count | first identifier | last identifier |
-      | state=[int:1]    | state code       | 2     | code=[int:1]     | code=[int:3]    |
-      | state=[nil:]     | state code       | 1     | code=[int:2]     | code=[int:2]    |
-      | title=[nil:]     | title code       | 2     | code=[int:1]     | code=[int:2]    |

data/features/relation/query_methods/reorder.feature

@@ -1,29 +0,0 @@
-Feature: reorder by hydra attributes
-  When reorder relation object with new hydra attributes
-  Then old order hydra attributes should be removed
-  And new hydra attributes should be added to order list
-
-  Background: create hydra attributes
-    Given create hydra attributes for "Product" with role "admin" as "hashes":
-      | name  | backend_type | white_list |
-      | code  | integer      | [bool:t]   |
-      | state | integer      | [bool:t]   |
-      | title | string       | [bool:t]   |
-
-  Scenario Outline: reorder
-    Given create "Product" model with attributes as "hashes":
-      | code | name | title |
-      | 1    | a    | c     |
-      | 2    | b    | b     |
-      | 3    | c    | a     |
-    When order "Product" records by "<order>"
-    And reorder records by "<reorder>"
-    Then total records should be "<count>"
-    And "first" record should have "<first identifier>"
-    And "last" record should have "<last identifier>"
-
-    Scenarios: order conditions
-      | order | reorder    | count | first identifier | last identifier |
-      | title | name title | 3     | code=[int:1]     | code=[int:3]    |
-      | name  | title name | 3     | code=[int:3]     | code=[int:1]    |
-      | code  | title      | 3     | code=[int:3]     | code=[int:1]    |

data/features/relation/query_methods/reverse_order.feature

@@ -1,29 +0,0 @@
-Feature: reverse order relation object
-  When reverse order by hydra attribute
-  Then relation object should reverse order of hydra attribute. ASC to DESC and vise versa
-
-  Background: create hydra attributes
-    Given create hydra attributes for "Product" with role "admin" as "hashes":
-      | name  | backend_type | white_list |
-      | code  | integer      | [bool:t]   |
-      | state | integer      | [bool:t]   |
-      | title | string       | [bool:t]   |
-
-  Scenario Outline: reverse order
-    Given create "Product" model with attributes as "hashes":
-      | code | state | title |
-      | 1    | 3     | a     |
-      | 2    | 2     | b     |
-      | 3    | 1     | c     |
-    When order "Product" records by "<order>"
-    And reverse order records
-    Then total records should be "3"
-    And "first" record should have "<first>"
-    And "last" record should have "<last>"
-
-    Scenarios: conditions
-      | order | first        | last         |
-      | code  | code=[int:3] | code=[int:1] |
-      | state | code=[int:1] | code=[int:3] |
-      | title | code=[int:3] | code=[int:1] |
-

data/features/relation/query_methods/select.feature

@@ -1,50 +0,0 @@
-Feature: select concrete attributes
-  When select concrete attribute
-  Then model should response only to these attributes
-
-  Background: create hydra attributes
-    Given create hydra attributes for "Product" with role "admin" as "hashes":
-      | name     | backend_type | white_list |
-      | code     | integer      | [bool:t]   |
-      | price    | float        | [bool:t]   |
-      | title    | string       | [bool:t]   |
-      | note     | text         | [bool:t]   |
-      | active   | boolean      | [bool:t]   |
-      | schedule | datetime     | [bool:t]   |
-    And create "Product" model with attributes as "hashes":
-      | name | code | price | title | note | active | schedule   |
-      | a    | 1    | 4     | q     | z    | 1      | 2012-06-01 |
-      | b    | 2    | 5     | w     | x    | 0      | 2012-06-02 |
-      | c    | 3    | 6     |       | c    | 1      | 2012-06-03 |
-      | d    |      | 7     |       | v    | 0      | 2012-06-04 |
-
-  Scenario Outline: select concrete attributes
-    When "Product" select only the following columns "<selected columns>"
-    Then records should have only the following "<expected columns>" names
-    And records should raise "ActiveModel::MissingAttributeError" when call the following "<methods>"
-    And total records should be "4"
-
-    Scenarios: select attributes
-      | selected columns  | expected columns                  | methods                               |
-      | name              | id hydra_set_id name              | code price title note active schedule |
-      | name code         | id hydra_set_id name code         | price title note active schedule      |
-      | name code price   | id hydra_set_id name code price   | title note active schedule            |
-      | code price title  | id hydra_set_id code price title  | name note active schedule             |
-      | title note active | id hydra_set_id title note active | name code price schedule              |
-      | schedule          | id hydra_set_id schedule          | name code price title note active     |
-      | id schedule       | id hydra_set_id schedule          | name code price title note active     |
-
-  Scenario Outline: filter collection and select concrete attributes
-    When "Product" select only the following columns "<selected columns>"
-    And filter records by "<filter attributes>"
-    Then records should have only the following "<expected columns>" names
-    And records should raise "ActiveModel::MissingAttributeError" when call the following "<methods>"
-    And total records should be "<total>"
-
-    Scenarios: filter and select attributes
-      | selected columns | expected columns           | filter attributes | methods                               | total |
-      | name code        | id hydra_set_id name code  | name=a            | price title note active schedule      | 1     |
-      | code             | id hydra_set_id code       | code=[int:1]      | name price title note active schedule | 1     |
-      | name code        | id hydra_set_id name code  | code=[int:1]      | price title note active schedule      | 1     |
-      | code title       | id hydra_set_id code title | title=[nil:]      | name price note active schedule       | 2     |
-      | code note        | id hydra_set_id code note  | title=[nil:]      | name price title active schedule      | 2     |

data/features/relation/query_methods/where.feature

@@ -1,115 +0,0 @@
-Feature: hydra attribute where conditions
-  When filter by hydra attribute and this value is not nil
-  Then records with this attribute should be selected
-
-  When filter by hydra attribute and this value is nil
-  Then records with nil and blank value should be selected
-
-  Background: create hydra attributes
-    Given create hydra attributes for "Product" with role "admin" as "hashes":
-      | name    | backend_type | white_list |
-      | code    | string       | [bool:t]   |
-      | summary | string       | [bool:t]   |
-      | title   | string       | [bool:t]   |
-      | price   | float        | [bool:t]   |
-      | active  | boolean      | [bool:t]   |
-      | state   | integer      | [bool:t]   |
-
-  Scenario: filter by one hydra attribute
-    Given create "Product" model with attributes as "hashes":
-      | code | price |
-      | 1    | 2.75  |
-      | 2    | 2.75  |
-      | 3    | 2.76  |
-      | 4    |       |
-    When filter "Product" by:
-      | field | value |
-      | price | 2.75  |
-    Then total records should be "2"
-    And records should have the following attributes:
-      | field | value |
-      | code  | 1     |
-      | code  | 2     |
-
-  Scenario: filter by one hydra attribute with nil value
-    Given create "Product" model with attributes as "hashes":
-      | code | price |
-      | 1    |       |
-      | 2    | 0     |
-      | 3    |       |
-    When filter "Product" by:
-      | field | value  |
-      | price | [nil:] |
-    Then total records should be "2"
-    And records should have the following attributes:
-      | field | value |
-      | code  | 1     |
-      | code  | 3     |
-
-  Scenario: filter by several fields including both the hydra and general attributes
-    Given create "Product" model with attributes as "hashes":
-      | name | code | title | price | active | state  | summary |
-      | toy  | 1    | story | 2.40  | 1      |        |         |
-      | toy  | 2    | story | 2.45  | 1      |        |         |
-      | toy  | 3    | story | 2.45  | 1      |        |         |
-      | toy  | 4    |       | 2.45  | 0      |        |         |
-      |      | 5    |       | 2.45  | 1      |        |         |
-      | toy  | 6    |       | 2.46  | 1      |        |         |
-    When filter "Product" by:
-      | field   | value        |
-      | name    | toy          |
-      | title   | story        |
-      | summary | [nil:]       |
-      | price   | [float:2.45] |
-      | active  | [bool:t]     |
-      | state   | [nil:]       |
-    Then total records should be "2"
-    And records should have the following attributes:
-      | field | value |
-      | code  | 2     |
-      | code  | 3     |
-
-  Scenario: select entity if it has attribute in attribute set
-    Given  create hydra set "Default" for "Product"
-    And set hydra attributes "[array:code,title]" to hydra set "Default" for entity "Product"
-    And create "Product" models with attributes as "hashes":
-      | hydra_set_id                           | code | title |
-      |                                        | abc1 | book  |
-      | [eval:Product.hydra_set('Default').id] | abc2 | book  |
-    When filter "Product" by:
-      | field | value |
-      | title | book  |
-    Then total records should be "2"
-    And records should have the following attributes:
-      | field | value |
-      | code  | abc1  |
-      | code  | abc2  |
-
-  Scenario: when filter attribute by nil value then entities without this attribute in attribute set should not be selected
-    Given create hydra set "Default" for "Product"
-    And create "Product" model
-    And create "Product" model with attributes as "rows_hash":
-      | hydra_set_id | [eval:Product.hydra_set('Default').id] |
-    When filter "Product" by:
-      | field | value  |
-      | code  | [nil:] |
-    Then total records should be "1"
-    And records should have the following attributes:
-      | field        | value  |
-      | hydra_set_id | [nil:] |
-
-  Scenario: when filter attribute by value then entities which don't have this attribute in attribute set any more should not be selected
-    Given create hydra set "Default" for "Product"
-    And add hydra attribute "code" to hydra set "Default" for entity "Product"
-    And create "Product" models with attributes as "hashes":
-      | hydra_set_id                           | code |
-      |                                        | abc  |
-      | [eval:Product.hydra_set('Default').id] | abc  |
-    And set hydra attributes "title" to hydra set "Default" for entity "Product"
-    When filter "Product" by:
-      | field | value |
-      | code  | abc   |
-    Then total records should be "1"
-    And records should have the following attributes:
-      | field        | value  |
-      | hydra_set_id | [nil:] |

data/features/step_definitions/connections.rb

@@ -1,65 +0,0 @@
-Given /^create connection$/ do
-  spec        = ActiveRecord::Base::ConnectionSpecification.new({database: ':memory:', adapter: 'sqlite3'}, 'sqlite3_connection')
-  @connection = ActiveRecord::ConnectionAdapters::ConnectionPool.new(spec).connection
-end
-
-Given /^(create|drop|migrate|rollback)(?:\sto|\sfrom)? hydra entity "([^"]+)"$/ do |method, table|
-  HydraAttribute::Migrator.send(method, @connection, table)
-end
-
-Given /^create table "([^"]+)"$/ do |table|
-  @connection.create_table(table)
-end
-
-Then /^should have the following (\d+) tables?:$/ do |count, table|
-  @connection.should have(count.to_i).tables
-
-  table.rows.flatten.each do |name|
-    @connection.tables.should include(name)
-  end
-end
-
-Then /^should not have any tables$/ do
-  @connection.should have(0).tables
-end
-
-Then /^table "([^"]+)" should have the following (columns|indexes):$/ do |table_name, method, table|
-  connection_params = @connection.send(method, table_name).sort_by(&:name)
-  checked_params    = table.hashes.map { |hash| type_cast_hash(hash) }.sort_by { |param| param['name'] }
-
-  unless connection_params.length == checked_params.length
-    raise %(Table "#{table_name}" has "#{connection_params.length}" #{method} but in our test "#{checked_params.length}". Diff: is "#{connection_params.map(&:name)}" but should be "#{checked_params.map { |h| h['name'] }}")
-  end
-
-  connection_params.zip(checked_params).each do |(real_params, params)|
-    params.keys.each do |name|
-      params[name].should == real_params.send(name)
-    end
-  end
-end
-
-Then /^table "([^"]+)" should have (\d+) records?$/ do |table_name, count|
-  result = ActiveRecord::Base.connection.select_one("SELECT COUNT(*) AS count FROM #{table_name}")
-  result['count'].should == count.to_i
-end
-
-Then /^table "([^"]+)" should have (\d+) records?:$/ do |table_name, count, table|
-  step %(table "#{table_name}" should have #{count} records)
-
-  table.hashes.each do |hash|
-    table  = Arel::Table.new(table_name, ActiveRecord::Base)
-    select = Arel.sql('COUNT(*)').as('count')
-    where  = hash.map { |name, value| table[name].eq(type_cast_value(value)) }.inject(:and)
-
-    result = ActiveRecord::Base.connection.select_one(table.project(select).where(where))
-    unless result['count']
-      raise %(Query "#{table.project(select).where(where).to_sql}" return nil)
-    end
-
-    unless result['count'] == 1
-      raise %(Query "#{table.project(select).where(where).to_sql}" return "#{result['count']}")
-    end
-    result['count'].should be(1)
-  end
-end
-

data/features/step_definitions/model_steps.rb

@@ -1,136 +0,0 @@
-Given /^redefine "([^"]+)" class to use hydra attributes$/ do |klass|
-  redefine_hydra_entity(klass)
-end
-
-Given /^create "([^"]+)" model$/ do |klass|
-  klass.constantize.create!
-end
-
-Given /^build "([^"]+)" model$/ do |klass|
-  @model = klass.constantize.new
-end
-
-Given /^build "([^"]+)" model:$/ do |klass, table|
-  @model = klass.constantize.new(type_cast_hash(table.rows_hash))
-end
-
-When /^set "([^"]+)" to "([^"]+)"$/ do |attribute, value|
-  @model.send("#{attribute}=", type_cast_value(value))
-end
-
-When /^(save|destroy) model$/ do |method|
-  @model.send(method)
-end
-
-When /^find "([^"]+)" model by attribute "([^"]+)" and value "([^"]+)"$/ do |class_name, attribute, value|
-  @model = class_name.constantize.send("find_by_#{attribute}", type_cast_value(value))
-end
-
-When /^find (first|last) "([^"]+)" model$/ do |method, class_name|
-  @model = class_name.constantize.send(method)
-end
-
-When /^reload model$/ do
-  @model.reload
-end
-
-Given /^create "([^"]+)" model with attributes as "([^"]+):"$/ do |klass, format, table|
-  Array.wrap(table.send(format)).each do |hash|
-    klass.constantize.create!(type_cast_hash(hash))
-  end
-end
-
-Given /^create hydra attributes for "([^"]+)" with role "([^"]+)" as "([^"]+)":$/ do |klass, role, format, table|
-  Array.wrap(table.send(format)).each do |hash|
-    klass.constantize.hydra_attributes.create!(type_cast_hash(hash), as: role.to_sym)
-  end
-end
-
-Given /^create hydra sets for "([^"]+)" as "([^"]+)":$/ do |klass, format, table|
-  Array.wrap(table.send(format)).each do |hash|
-    step %(create hydra set "#{hash['name']}" for "#{klass}")
-  end
-end
-
-Given /^create hydra set "([^"]+)" for "([^"]+)"$/ do |hydra_set_name, klass|
-  klass.constantize.hydra_sets.create!(name: type_cast_value(hydra_set_name))
-end
-
-Given /^add "([^"]+)" hydra attributes to hydra set:$/ do |klass, table|
-  klass = klass.constantize
-
-  Array.wrap(table.hashes).each do |hash|
-    Array.wrap(type_cast_value(hash['hydra set name'])).each do |set|
-      klass.hydra_sets.find_by_name(set).hydra_attributes << klass.hydra_attributes.find_by_name(type_cast_value(hash['hydra attribute name']))
-    end
-  end
-end
-
-Given /^add hydra attribute "([^"]+)" to hydra set "([^"]+)" for entity "([^"]+)"$/ do |hydra_attribute, hydra_set, entity_class|
-  entity = entity_class.constantize
-  entity.hydra_set(type_cast_value(hydra_set)).hydra_attributes << entity.hydra_attribute(type_cast_value(hydra_attribute))
-end
-
-Given /^set hydra attributes? "([^"]+)" to hydra set "([^"]+)" for entity "([^"]+)"$/ do |hydra_attributes, hydra_set, entity_class|
-  entity    = entity_class.constantize
-  hydra_set = entity.hydra_set(type_cast_value(hydra_set))
-
-  hydra_attributes = Array(type_cast_value(hydra_attributes)).map { |attr| entity.hydra_attribute(attr) }
-  hydra_set.hydra_attributes = hydra_attributes
-end
-
-Given /^(load and )?(save|create|update(?: all| attributes)?|destroy(?: all)?|delete(?: all)?)(?: for)? "([^"]+)" models? with attributes as "([^"]+)":$/ do |load, action, klass, format, table|
-  action = action.gsub(' ', '_')
-  klass  = klass.constantize
-  models = load.present? ? klass.all : [klass]
-
-  Array.wrap(table.send(format)).each do |hash|
-    models.each do |model|
-      model.send(action, type_cast_hash(hash))
-    end
-  end
-end
-
-Then /^model (should(?:\snot)?) respond to "([^"]+)"$/ do |method, attributes|
-  method = method.gsub(/\s+/, '_')
-  attributes.split.each do |attribute|
-    @model.send(method, respond_to(attribute))
-  end
-end
-
-Then /^model attributes (should(?:\snot)?) include "([^"]+)"$/ do |method, attributes|
-  method = method.gsub(/\s+/, '_')
-  attributes.split.each do |attribute|
-    @model.attributes.keys.send(method, include(attribute))
-  end
-end
-
-Then /^model attributes (should(?:\snot)?) match "([^"]+)"$/ do |match, attribute|
-  @model.attributes.keys.send(match) =~ Array(type_cast_value(attribute))
-end
-
-Then /^model "([^"]+)" (should(?:\snot)?) respond to "([^"]+)"$/ do |klass, method, attributes|
-  @model = klass.constantize.new
-  step %(model #{method} respond to "#{attributes}")
-end
-
-Then /^error "([^"]+)" (should(?:\snot)?) be risen when methods? "([^"]+)" (?:is|are) called$/ do |error_class, expect, methods|
-  Array.wrap(methods.split).each do |method|
-    lambda { @model.send(method) }.send(expect.gsub(/\s+/, '_'), raise_error(error_class.constantize))
-  end
-end
-
-Then /^(last|first) created "([^"]+)" (should|should not) have the following attributes:$/ do |position, klass, match, table|
-  table.rows_hash.each do |attribute, value|
-    step %(#{position} created "#{klass}" #{match} have attribute "#{attribute}" with value "#{value}")
-  end
-end
-
-Then /^(last|first) created "([^"]+)" (should|should not) have attribute "([^"]+)" with value "([^"]+)"$/ do |position, klass, match, attribute, value|
-  klass.constantize.send(position).send(attribute).send(match) == type_cast_value(value)
-end
-
-Then /^class "([^"]+)" (should(?:\snot)?) have "([^"]+)" in white list$/ do |klass, accept, attribute|
-  method = accept.sub(' ', '_')
-  klass.constantize.accessible_attributes.send(method, include(attribute))
-end