hydra_attribute 0.1.0

data/features/order_conditions.feature

@@ -0,0 +1,93 @@
+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
+
+  When reorder by attributes
+  Then old hydra attributes should be removed and new should be added
+
+  Background: create models and describe hydra attributes
+    Given removed constants if they exist:
+      | name          |
+      | GroupProduct  |
+      | SimpleProduct |
+      | Product       |
+    And create model class "Product"
+    And create model class "SimpleProduct" as "Product" with hydra attributes:
+      | type    | name  |
+      | integer | code  |
+      | integer | state |
+      | string  | title |
+
+  Scenario Outline: order by one field
+    Given create models:
+      | model         | attributes                                         |
+      | SimpleProduct | name=[string:c] code=[integer:1] state=[integer:1] |
+      | SimpleProduct | name=[string:b] code=[integer:2] state=[integer:2] |
+      | SimpleProduct | name=[string:a] code=[integer:3] state=[integer:3] |
+    When order "SimpleProduct" records by "<attributes>"
+    Then "first" record should have "<first>"
+    And "last" record should have "<last>"
+
+    Scenarios: order conditions
+      | attributes | first            | last             |
+      | state=asc  | code=[integer:1] | code=[integer:3] |
+      | state=desc | code=[integer:3] | code=[integer:1] |
+      | name=asc   | code=[integer:3] | code=[integer:1] |
+      | name=desc  | code=[integer:1] | code=[integer:3] |
+
+  Scenario Outline: order by several fields
+    Given create models:
+      | model         | attributes                                                          |
+      | SimpleProduct | name=[string:c] code=[integer:1] state=[integer:1] title=[string:b] |
+      | SimpleProduct | name=[string:b] code=[integer:2] state=[integer:2] title=[string:a] |
+      | SimpleProduct | name=[string:a] code=[integer:3] state=[integer:3] title=[string:c] |
+    When order "SimpleProduct" records by "<attributes>"
+    Then "first" record should have "<first>"
+    And "last" record should have "<last>"
+
+    Scenarios: order conditions
+      | attributes  | first            | last             |
+      | name state  | code=[integer:3] | code=[integer:1] |
+      | state title | code=[integer:1] | code=[integer:3] |
+      | title state | code=[integer:2] | code=[integer:3] |
+
+  Scenario Outline: order by already joined field
+    Given create models:
+      | model         | attributes                                          |
+      | SimpleProduct | code=[integer:1] state=[integer:1]                  |
+      | SimpleProduct | code=[integer:2]                   title=[nil:]     |
+      | SimpleProduct | code=[integer:3] state=[integer:1] title=[string:a] |
+    When filter "SimpleProduct" records by "<filter>"
+    And order records by "<order>"
+    Then total records should be "<count>"
+    And "first" record should have "<first>"
+    And "last" record should have "<last>"
+
+    Scenarios:
+      | filter            | order      | count | first            | last             |
+      | state=[integer:1] | state code | 2     | code=[integer:1] | code=[integer:3] |
+      | state=[nil:]      | state code | 1     | code=[integer:2] | code=[integer:2] |
+      | title=[nil:]      | title code | 2     | code=[integer:1] | code=[integer:2] |
+
+  Scenario Outline: reorder by hydra attributes
+    Given create models:
+      | model         | attributes                                        |
+      | SimpleProduct | code=[integer:1] name=[string:a] title=[string:c] |
+      | SimpleProduct | code=[integer:2] name=[string:b] title=[string:b] |
+      | SimpleProduct | code=[integer:3] name=[string:c] title=[string:a] |
+    When order "SimpleProduct" records by "<order>"
+    And reorder records by "<reorder>"
+    Then total records should be "<count>"
+    And "first" record should have "<first>"
+    And "last" record should have "<last>"
+
+    Scenarios:
+      | order | reorder    | count | first            | last             |
+      | title | name title | 3     | code=[integer:1] | code=[integer:3] |
+      | name  | title name | 3     | code=[integer:3] | code=[integer:1] |

data/features/select_attributes.feature

@@ -0,0 +1,56 @@
+Feature: select concrete attributes
+  When select hydra attribute
+  Then hydra attribute table should be joined and concrete attribute should be selected
+
+  Background: create models and describe hydra attributes
+    Given removed constants if they exist:
+      | name          |
+      | GroupProduct  |
+      | SimpleProduct |
+      | Product       |
+    And create model class "Product"
+    And create model class "SimpleProduct" as "Product" with hydra attributes:
+      | type     | name     |
+      | integer  | code     |
+      | float    | price    |
+      | string   | title    |
+      | text     | note     |
+      | boolean  | active   |
+      | datetime | schedule |
+    And create models:
+      | model         | attributes                                                                                                                              |
+      | SimpleProduct | name=[string:a] code=[integer:1] price=[float:4] title=[string:q] note=[string:z] active=[boolean:true]  schedule=[datetime:2012-06-01] |
+      | SimpleProduct | name=[string:b] code=[integer:2] price=[float:5] title=[string:w] note=[string:x] active=[boolean:false] schedule=[datetime:2012-06-02] |
+      | SimpleProduct | name=[string:c] code=[integer:3] price=[float:6]                  note=[string:c] active=[boolean:true]  schedule=[datetime:2012-06-03] |
+      | SimpleProduct | name=[string:d] code=[nil:]      price=[float:7]                  note=[string:v] active=[boolean:false] schedule=[datetime:2012-06-04] |
+
+  Scenario Outline: select concrete attributes
+    When "SimpleProduct" select only the following columns "<columns>"
+    Then records should have only the following "<columns>" names
+    And records should raise "ActiveModel::MissingAttributeError" when call the following "<methods>"
+    And total records should be "4"
+
+      Scenarios: select attributes
+        | columns           | methods                               |
+        | name              | code price title note active schedule |
+        | name code         | price title note active schedule      |
+        | name code price   | title note active schedule            |
+        | code price title  | name note active schedule             |
+        | title note active | name code price schedule              |
+        | schedule          | name code price title note active     |
+        | id schedule       | name code price title note active     |
+
+  Scenario Outline: filter collection and select concrete attributes
+    When "SimpleProduct" select only the following columns "<columns>"
+    And filter records by "<filter attributes>"
+    Then records should have only the following "<columns>" names
+    And records should raise "ActiveModel::MissingAttributeError" when call the following "<methods>"
+    And total records should be "<total>"
+
+    Scenarios: filter and select attributes
+      | columns    | filter attributes | methods                               | total |
+      | name code  | name=[string:a]   | price title note active schedule      | 1     |
+      | code       | code=[integer:1]  | name price title note active schedule | 1     |
+      | name code  | code=[integer:1]  | price title note active schedule      | 1     |
+      | code title | title=[nil:]      | name price note active schedule       | 2     |
+      | code note  | title=[nil:]      | name price title active schedule      | 2     |

data/features/step_definitions/class_steps.rb

@@ -0,0 +1,32 @@
+Given /^removed constants if they exist:$/ do |table|
+  table.hashes.each do |hash|
+    Object.send(:remove_const, hash[:name]) if Object.const_defined?(hash[:name])
+  end
+end
+
+Given /^create model class "([^"]+)"$/ do |klass|
+  Object.const_set(klass, Class.new(ActiveRecord::Base))
+end
+
+Given /^create model class "([^"]+)" as "([^"]+)" with hydra attributes:$/ do |klass, sti_class, table|
+  Object.const_set klass, Class.new(Object.const_get(sti_class)) {
+    define_hydra_attributes do |hydra|
+      table.hashes.each do |hash|
+        hydra.send(hash[:type], hash[:name].to_sym)
+      end
+    end
+  }
+end
+
+Then /^class "([^"]+)"::"([^"]+)" "(should|should_not)" have (string|symbol) "([^"]+)" in array$/ do |klass, method, behavior, type, params|
+  klass  = Object.const_get(klass)
+  params = params.split
+  params.map!(&:to_sym) if type == 'symbol'
+  klass.send(method).send(behavior) =~ params
+end
+
+Then /^class "([^"]+)"::"([^"]+)" "(should|should_not)" have "([^"]+)" hash$/ do |klass, method, behavior, params|
+  klass = Object.const_get(klass)
+  array = params.split.map{ |item| item.split('=').map(&:to_sym) }
+  klass.send(method).send(behavior) == Hash[array].stringify_keys
+end

data/features/step_definitions/model_steps.rb

@@ -0,0 +1,31 @@
+Given /^create models:$/ do |table|
+  table.hashes.each do |hash|
+    attributes = typecast_attributes(hash[:attributes])
+    Object.const_get(hash[:model]).create!(attributes)
+  end
+end
+
+Given /^create model "([^"]+)" with attributes "([^"]+)"$/ do |klass, attributes|
+  attrs  = typecast_attributes(attributes)
+  @model = Object.const_get(klass).create!(attrs)
+end
+
+Then /^model "([^"]+)" should "(should|should_not)" to "([^"]+)"$/ do |klass, method, attributes|
+  model = Object.const_get(klass).new
+  attributes.split.each do |attribute|
+    model.send(method, respond_to(attribute))
+  end
+end
+
+Then /^it should have typecast attributes "([^"]+)"$/ do |attributes|
+  @model.reload # ensure that all attributes have correct type
+  typecast_attributes(attributes).each do |name, value|
+    @model.send(name).should == value
+  end
+end
+
+Then /^model "([^"]+)" should have only the following ((?:hydra )?attributes(?: before type cast)?) "([^"]+)"$/ do |klass, method, attributes|
+  model  = Object.const_get(klass).new
+  method = method.gsub(/\s+/, '_')
+  model.send(method).keys.should =~ attributes.split(/\s+/)
+end

data/features/step_definitions/record_steps.rb

@@ -0,0 +1,103 @@
+When /^load all "([^"]+)" records$/ do |klass|
+  @records = Object.const_get(klass).all
+end
+
+When /^select "(first|last)" "([^"]+)" record$/ do |method, klass|
+  @record = Object.const_get(klass).send(method)
+end
+
+When /^filter "([^"]+)" by:$/ do |klass, table|
+  condition = table.hashes.each_with_object({}) { |item, hash| hash[item[:field].to_sym] = typecast_value(item[:value]) }
+  @records  = Object.const_get(klass).where(condition)
+end
+
+When /^filter "([^"]+)" records by "([^"]+)"$/ do |klass, attribute|
+  @records = Object.const_get(klass)
+  step %Q(filter records by "#{attribute}")
+end
+
+When /^filter records by "([^"]+)"$/ do |attribute|
+  name, value = typecast_attribute(attribute)
+  @records = @records.where(name => value)
+end
+
+When /^(order|reorder) "([^"]+)" records by "([^"]+)"$/ do |sort_method, klass, attributes|
+  @records = Object.const_get(klass)
+  step %Q(#{sort_method} records by "#{attributes}")
+end
+
+When /^(order|reorder) records by "([^"]+)"$/ do |sort_method, attributes|
+  reverse  = false
+  fields   = attributes.split.inject([]) do |items, attribute|
+    name, direction = attribute.split('=')
+    reverse = true if direction == 'desc'
+    items << name.to_sym
+  end
+
+  @records = @records.send(sort_method, fields)
+  @records = @records.reverse_order if reverse
+end
+
+When /^"([^"]+)" select only the following columns "([^"]+)"$/ do |klass, columns|
+  @records = Object.const_get(klass).select(columns.split(/\s+/).map(&:to_sym))
+end
+
+Then /^record should have the following ((?:hydra )?attributes(?: before type cast)?) "([^"]+)" in attribute hash$/ do |method, attributes|
+  method = method.gsub(/\s+/, '_')
+  typecast_attributes(attributes).each do |(name, value)|
+    @record.send(method)[name.to_s].should == value
+  end
+end
+
+Then /^record (read attribute(?: before type cast)?) "([^"]+)" and value should be "([^"]+)"$/ do |method, attribute, value|
+  method = method.gsub(/\s+/, '_')
+  @record.send(method, attribute).should == typecast_value(value)
+end
+
+Then /^"(first|last)" record should have "([^"]+)"$/ do |method, attribute|
+  name, value = typecast_attribute(attribute)
+  @records.send(method).send(name).should == value
+end
+
+Then /^records should have the following attributes:$/ do |table|
+  table.hashes.each do |hash|
+    record = @records.detect { |r| r.send(hash[:field]) == typecast_value(hash[:value]) }
+    record.should_not be_nil
+  end
+end
+
+Then /^records should have only the following "([^"]+)" names$/ do |attributes|
+  @records.each do |record|
+    record.attributes.keys.should == attributes.split(/\s+/)
+  end
+end
+
+Then /^records should raise "([^"]+)" when call the following "([^"]+)"$/ do |error, methods|
+  error_class = error.constantize
+  @records.each do |record|
+    methods.split(/\s+/).each do |method|
+      lambda { record.send(method) }.should raise_error(error_class)
+    end
+  end
+end
+
+Then /^total records should be "([^"]+)"$/ do |count|
+  @records.should have(count.to_i).items
+end
+
+Then /^records "(should|should_not)" have loaded associations:$/ do |should, table|
+  table.hashes.each do |hash|
+    @records.each do |record|
+      record.association(hash[:association].to_sym).send(should, be_loaded)
+    end
+  end
+end
+
+Then /^"([^"]+)" records "(should|should_not)" have loaded associations:$/ do |klass, should, table|
+  table.hashes.each do |hash|
+    records = @records.select { |record| record.class.name == klass }
+    records.each do |record|
+      record.association(hash[:association].to_sym).send(should, be_loaded)
+    end
+  end
+end

data/features/support/env.rb

@@ -0,0 +1,24 @@
+require 'active_record'
+require 'hydra_attribute'
+require 'database_cleaner'
+require 'database_cleaner/cucumber'
+
+
+ActiveRecord::Base.default_timezone = :utc
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+ActiveRecord::Base.extend(HydraAttribute::ActiveRecord)
+
+DatabaseCleaner.strategy = :truncation
+
+Before do
+  HydraAttribute::SUPPORT_TYPES.each do |type|
+    const = HydraAttribute.config.associated_const_name(type)
+    HydraAttribute.send(:remove_const, const) if HydraAttribute.const_defined?(const)
+  end
+  ActiveSupport::Dependencies::Reference.clear!
+  DatabaseCleaner.start
+end
+
+After do
+  DatabaseCleaner.clean
+end

data/features/support/schema.rb

@@ -0,0 +1,51 @@
+ActiveRecord::Schema.define do
+  create_table "products", :force => true do |t|
+    t.string   "type"
+    t.string   "name"
+    t.string   "info"
+    t.datetime "created_at", :null => false
+    t.datetime "updated_at", :null => false
+  end
+
+  create_table "hydra_string_attributes", :force => true do |t|
+    t.integer "entity_id"
+    t.string  "entity_type"
+    t.string  "name"
+    t.string  "value"
+  end
+
+  create_table "hydra_float_attributes", :force => true do |t|
+    t.integer "entity_id"
+    t.string  "entity_type"
+    t.string  "name"
+    t.float   "value"
+  end
+
+  create_table "hydra_boolean_attributes", :force => true do |t|
+    t.integer "entity_id"
+    t.string  "entity_type"
+    t.string  "name"
+    t.boolean "value"
+  end
+
+  create_table "hydra_integer_attributes", :force => true do |t|
+    t.integer "entity_id"
+    t.string  "entity_type"
+    t.string  "name"
+    t.integer "value"
+  end
+
+  create_table "hydra_text_attributes", :force => true do |t|
+    t.integer "entity_id"
+    t.string  "entity_type"
+    t.string  "name"
+    t.text    "value"
+  end
+
+  create_table "hydra_datetime_attributes", :force => true do |t|
+    t.integer  "entity_id"
+    t.string   "entity_type"
+    t.string   "name"
+    t.datetime "value"
+  end
+end

data/features/support/world.rb

@@ -0,0 +1,31 @@
+module HydraAttribute
+  module Cucumber
+    module World
+      def typecast_value(schema)
+        type, value = schema.gsub(/\[|\]/, '').split(':', 2)
+        case type
+        when 'integer'  then value.to_i
+        when 'float'    then value.to_f
+        when 'boolean'  then value == 'true' ? true : false
+        when 'nil'      then nil
+        when 'datetime' then ActiveSupport::TimeZone.new('UTC').parse(value)
+        else value
+        end
+      end
+
+      def typecast_attribute(attribute)
+        name, schema = attribute.split('=')
+        [name.to_sym, typecast_value(schema)]
+      end
+
+      def typecast_attributes(attributes)
+        attributes.split(/(?<=\])\s+/).flatten.each_with_object({}) do |attribute, hash|
+          name, value = typecast_attribute(attribute)
+          hash[name]  = value
+        end
+      end
+    end
+  end
+end
+
+World(HydraAttribute::Cucumber::World)

data/features/typecast_attributes.feature

@@ -0,0 +1,29 @@
+Feature: create model
+  Model should be created with typecast hydra attributes.
+
+  Background: create models and describe hydra attributes
+    Given removed constants if they exist:
+      | name          |
+      | GroupProduct  |
+      | SimpleProduct |
+      | Product       |
+    And create model class "Product"
+    And create model class "SimpleProduct" as "Product" with hydra attributes:
+      | type   | name  |
+      | string | code  |
+      | float  | price |
+    And create model class "GroupProduct" as "Product" with hydra attributes:
+      | type    | name   |
+      | float   | price  |
+      | string  | title  |
+      | boolean | active |
+
+  Scenario Outline: create model with hydra attributes
+    Given create model "<model>" with attributes "<attributes>"
+    Then it should have typecast attributes "<typecast_attributes>"
+
+    Scenarios:
+      | model         | attributes                                            | typecast_attributes                                    |
+      | SimpleProduct | code=[integer:1] price=[string:2.75]                  | code=[string:1] price=[float:2.75]                     |
+      | GroupProduct  | price=[string:2] title=[integer:1] active=[integer:1] | price=[float:2] title=[string:1] active=[boolean:true] |
+      | GroupProduct  | active=[integer:0]                                    | price=[nil:] title=[nil:] active=[boolean:false]       |