ruby_odata 0.0.10 → 0.1.0

data/features/service.feature

@@ -4,7 +4,7 @@ Feature: Service Should Generate a Proxy
   I want to be able to access data
 
 Background:
-  Given a sample HTTP ODataService exists
+  Given a HTTP ODataService exists
   And blueprints exist for the service
 
 Scenario: Service should respond to valid collections
@@ -21,29 +21,29 @@ Scenario: Access an entity by ID should return the entity type
   And I save changes
   And I call "Categories" on the service with args: "1"
   When I run the query
-  Then the result should be of type "Category"
+  Then the first result should be of type "Category"
 
 Scenario: Entity should have the correct accessors
   Given I call "AddToCategories" on the service with a new "Category" object with Name: "Test Category"
   And I save changes
   And I call "Categories" on the service with args: "1"
   When I run the query
-  Then the result should have a method: "Id"
-  And the result should have a method: "Name"
+  Then the first result should have a method: "Id"
+  And the first result should have a method: "Name"
   
 Scenario: Entity should fill values
   Given I call "AddToCategories" on the service with a new "Category" object with Name: "Test Category"
   And I save changes
   And I call "Categories" on the service with args: "1"
   When I run the query
-  Then the method "Id" on the result should equal: "1"
-  And the method "Name" on the result should equal: "Test Category"
+  Then the method "Id" on the first result should equal: "1"
+  And the method "Name" on the first result should equal: "Test Category"
 
 Scenario: Navigation Properties should be included in results	
   Given I call "AddToProducts" on the service with a new "Product" object
   And I save changes		
   And I call "Products" on the service with args: "1"
   When I run the query
-  Then the result should have a method: "Category"
-  And the method "Category" on the result should be nil
+  Then the first result should have a method: "Category"
+  And the method "Category" on the first result should be nil
 

data/features/service_manage.feature

@@ -4,20 +4,20 @@ Feature: Service management
   I want to be able to add, edit, and delete entities
 
 Background:
-  Given an ODataService exists with uri: "http://localhost:8989/SampleService/Entities.svc"
+  Given a HTTP ODataService exists
   And blueprints exist for the service
 
 Scenario: Service should respond to AddToEntityName for adding objects
   Given I call "AddToProducts" on the service with a new "Product" object with Name: "Sample Product"
   When I save changes
-  Then the save result should be of type "Product"
-  And the method "Name" on the save result should equal: "Sample Product"
+  Then the first save result should be of type "Product"
+  And the method "Name" on the first save result should equal: "Sample Product"
 
 Scenario: Service should allow for deletes
   Given I call "AddToProducts" on the service with a new "Product" object
   When I save changes
-  Then the save result should be of type "Product"
-  When I call "delete_object" on the service with the last save result
+  Then the first save result should be of type "Product"
+  When I call "delete_object" on the service with the first last save result
   And I save changes
   Then the save result should equal: "true" 
   And no "Products" should exist
@@ -30,15 +30,15 @@ Scenario: Entities should be able to be updated
   When I save changes
   And I call "Products" on the service with args: "1"
   And I run the query
-  Then the method "Name" on the result should equal: "Test Product"
-  When I set "Name" on the result to "Changed Test Product"
-  Then the method "Name" on the result should equal: "Changed Test Product"
-  And I call "update_object" on the service with the last query result
+  Then the method "Name" on the first result should equal: "Test Product"
+  When I set "Name" on the first result to "Changed Test Product"
+  Then the method "Name" on the first result should equal: "Changed Test Product"
+  And I call "update_object" on the service with the first last query result
   And I save changes
   Then the save result should equal: "true"
   When I call "Products" on the service with args: "1"
   And I run the query
-  Then the method "Name" on the result should equal: "Changed Test Product"
+  Then the method "Name" on the first result should equal: "Changed Test Product"
 
 Scenario: Untracked entities shouldn't be able to be updated
   Given I call "update_object" on the service with a new "Product" object it should throw an exception with message "You cannot update a non-tracked entity"
@@ -46,9 +46,24 @@ Scenario: Untracked entities shouldn't be able to be updated
 Scenario: Related entities shouldn't be recreated on a child add
   Given I call "AddToCategories" on the service with a new "Category" object with Name: "Test Category"
   And I save changes
-  And I call "AddToProducts" on the service with a new "Product" object with Category: "@@LastSave"
+  And I call "AddToProducts" on the service with a new "Product" object with Category: "@@LastSave.first"
   And I save changes	
   And I call "Products" on the service with args: "1"
   And I expand the query to include "Category"
   When I run the query
-  Then the method "Id" on the result's method "Category" should equal: "1"
+  Then the method "Id" on the first result's method "Category" should equal: "1"
+
+Scenario: Entities should be able to be linked together
+  Given a category: "cat1" exists
+  And a product: "prod1" exists
+  When I add a link between category: "cat1" and product: "prod1" on "Products"
+  And I save changes
+  Then the product: "prod1" should be one of category: "cat1"'s Products
+
+Scenario: Entities should be able to be linked together on a batch save
+  Given a category: "cat1" exists
+  And a product: "prod1" exists
+  When I add a link between category: "cat1" and product: "prod1" on "Products"
+  And I call "AddToCategories" on the service with a new "Category" object with Name: "Test Category"
+  And I save changes
+  Then the product: "prod1" should be one of category: "cat1"'s Products

data/features/service_methods.feature

@@ -0,0 +1,37 @@
+Feature: Service methods
+  In order to use a WCF Data Service more efficiently
+  As a consumer
+  I want to be able to utilize custom WCF DS methods
+
+Background:
+  Given a HTTP ODataService exists
+  And blueprints exist for the service  
+
+  
+Scenario: A custom web get (no parameters) that returns an entity
+  Given a category exists
+  And I call the service method "EntityCategoryWebGet"
+  Then the first result should be of type "Category"
+
+Scenario: A custom web get (with parameters) that returns a single entity
+  Given a category: "cat1" exists with Id: 1
+  When I call the service method "EntitySingleCategoryWebGet" with 1
+  Then the result should be of type "Category"
+  And the method "Id" on the result should equal: "1"
+
+Scenario: A custom web get that returns a collection of primitive types
+  Given the following categories exist:
+  | Name |
+  | Cat1 |
+  | Cat2 |
+  | Cat3 |
+  When I call the service method "CategoryNames"
+  Then the primitive results should be:
+  | Cat1  |
+  | Cat2  |
+  | Cat3  |
+
+Scenario: A custom web get that returns a single primitive type
+  Given a category exists
+  When I call the service method "FirstCategoryId"
+  Then the integer result should be 1

data/features/ssl.feature

@@ -1,7 +1,7 @@
 Feature: Service Should Access Basic Resources via SSL using a self-signed certificate
   
 Background:
-  Given an ODataService exists with uri: "https://localhost:44300/SampleService/BasicAuth/Entities.svc" using self-signed certificate and username "admin" and password "passwd"
+  Given a HTTPS BasicAuth ODataService exists using self-signed certificate and username "admin" and password "passwd"
   And blueprints exist for the service
 
 Scenario: Service should respond to valid collections
@@ -12,10 +12,10 @@ Scenario: Entity should fill values on protected resource
   And I save changes
   And I call "Categories" on the service with args: "1"
   When I run the query
-  Then the method "Id" on the result should equal: "1"
-  And the method "Name" on the result should equal: "Auth Test Category"
+  Then the method "Id" on the first result should equal: "1"
+  And the method "Name" on the first result should equal: "Auth Test Category"
 
 Scenario: Should get SSL failure if SSL used with self-signed certificate and not passing "false" as :verify_ssl option
-  Given an ODataService exists with uri: "https://localhost:44300/SampleService/Entities.svc" it should throw an exception with message containing "SSL Verification failed"
+  Given a HTTPS BasicAuth ODataService exists it should throw an exception with message containing "SSL Verification failed"
 
 

data/features/step_definitions/pickle_steps.rb

@@ -0,0 +1,100 @@
+# this file generated by script/generate pickle
+
+# create a model
+Given(/^#{capture_model} exists?(?: with #{capture_fields})?$/) do |name, fields|
+  create_model(name, fields)
+end
+
+# create n models
+Given(/^(\d+) #{capture_plural_factory} exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
+  count.to_i.times { create_model(plural_factory.singularize, fields) }
+end
+
+# create models from a table
+Given(/^the following #{capture_plural_factory} exists?:?$/) do |plural_factory, table|
+  create_models_from_table(plural_factory, table)
+end
+
+# find a model
+Then(/^#{capture_model} should exist(?: with #{capture_fields})?$/) do |name, fields|
+  find_model!(name, fields)
+end
+
+# not find a model
+Then(/^#{capture_model} should not exist(?: with #{capture_fields})?$/) do |name, fields|
+  find_model(name, fields).should be_nil
+end
+
+# find models with a table
+Then(/^the following #{capture_plural_factory} should exists?:?$/) do |plural_factory, table|
+  find_models_from_table(plural_factory, table).should_not be_any(&:nil?)
+end
+
+# find exactly n models
+Then(/^(\d+) #{capture_plural_factory} should exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
+  find_models(plural_factory.singularize, fields).size.should == count.to_i
+end
+
+# assert equality of models
+Then(/^#{capture_model} should be #{capture_model}$/) do |a, b|
+  model!(a).should == model!(b)
+end
+
+# assert model is in another model's has_many assoc
+Then(/^#{capture_model} should be (?:in|one of|amongst) #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model_with_associations(owner).send(association).should include(model!(target))
+end
+
+# assert model is not in another model's has_many assoc
+Then(/^#{capture_model} should not be (?:in|one of|amongst) #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model!(owner).send(association).should_not include(model!(target))
+end
+
+# assert model is another model's has_one/belongs_to assoc
+Then(/^#{capture_model} should be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model!(owner).send(association).should == model!(target)
+end
+
+# assert model is not another model's has_one/belongs_to assoc
+Then(/^#{capture_model} should not be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model!(owner).send(association).should_not == model!(target)
+end
+
+# assert model.predicate? 
+Then(/^#{capture_model} should (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
+  if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
+    model!(name).should send("have_#{predicate.gsub(' ', '_')}")
+  else
+    model!(name).should send("be_#{predicate.gsub(' ', '_')}")
+  end
+end
+
+# assert not model.predicate?
+Then(/^#{capture_model} should not (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
+  if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
+    model!(name).should_not send("have_#{predicate.gsub(' ', '_')}")
+  else
+    model!(name).should_not send("be_#{predicate.gsub(' ', '_')}")
+  end
+end
+
+# model.attribute.should eql(value)
+# model.attribute.should_not eql(value)
+Then(/^#{capture_model}'s (\w+) (should(?: not)?) be #{capture_value}$/) do |name, attribute, expectation, expected|
+  actual_value  = model(name).send(attribute)
+  expectation   = expectation.gsub(' ', '_')
+  
+  case expected
+  when 'nil', 'true', 'false'
+    actual_value.send(expectation, send("be_#{expected}"))
+  when /^[+-]?[0-9_]+(\.\d+)?$/
+    actual_value.send(expectation, eql(expected.to_f))
+  else
+    actual_value.to_s.send(expectation, eql(eval(expected)))
+  end
+end
+
+# assert size of association
+Then /^#{capture_model} should have (\d+) (\w+)$/ do |name, size, association|
+  model!(name).send(association).size.should == size.to_i
+end

data/features/step_definitions/service_steps.rb

@@ -1,29 +1,53 @@
-Given /^an ODataService exists with uri: "([^\"]*)"$/ do |uri|
-  @service = OData::Service.new(uri)
+STANDARD_URL = "http://#{WEBSERVER}:#{HTTP_PORT_NUMBER}/SampleService/RubyOData.svc"
+BASICAUTH_URL = "http://#{WEBSERVER}:#{HTTP_PORT_NUMBER}/SampleService/BasicAuth/RubyOData.svc"
+HTTPS_BASICAUTH_URL = "https://#{WEBSERVER}:#{HTTPS_PORT_NUMBER}/SampleService/BasicAuth/RubyOData.svc"
+
+When /^(.*) first (last query )?result('s)?(.*)$/ do |pre, last_query, apos, post|
+  step = "#{pre} #{last_query}result#{apos}#{post}"
+  first_result
+  When step
+end
+
+When /^(.*) first (last )?save result(.*)$/ do |pre, last, post|
+  step = "#{pre} #{last}save result#{post}"
+  first_save
+  When step
+end
+
+Given /^a HTTP ODataService exists$/ do
+  @service = OData::Service.new(STANDARD_URL)
 end
 
-Given /^a sample HTTP ODataService exists$/ do
-  @service = OData::Service.new("http://localhost:#{HTTP_PORT_NUMBER}/SampleService/Entities.svc")
+Given /^a HTTP BasicAuth ODataService exists$/ do
+  @service = OData::Service.new(BASICAUTH_URL)
 end
 
-Given /^an ODataService exists with uri: "([^\"]*)" using username "([^\"]*)" and password "([^\"]*)"$/ do |uri, username, password|
-  @service = OData::Service.new(uri, { :username => username, :password => password })
+Given /^a HTTPS BasicAuth ODataService exists$/ do
+  @service = OData::Service.new(HTTPS_BASICAUTH_URL)
 end
 
-Given /^an ODataService exists with uri: "([^\"]*)" using username "([^\"]*)" and password "([^\"]*)" it should throw an exception with message "([^\"]*)"$/ do |uri, username, password, msg|  
-  lambda { @service = OData::Service.new(uri, { :username => username, :password => password }) }.should raise_error(msg)
+Given /^a HTTP BasicAuth ODataService exists using username "([^\"]*)" and password "([^\"]*)"$/ do |username, password|
+  @service = OData::Service.new(BASICAUTH_URL, { :username => username, :password => password })
 end
 
-Given /^an ODataService exists with uri: "([^\"]*)" it should throw an exception with message containing "([^\"]*)"$/ do |uri, msg|  
-  lambda { @service = OData::Service.new(uri) }.should raise_error(/#{msg}.*/)
+Given /^a HTTP BasicAuth ODataService exists using username "([^\"]*)" and password "([^\"]*)" it should throw an exception with message "([^\"]*)"$/ do |username, password, msg|  
+  lambda { @service = OData::Service.new(BASICAUTH_URL, { :username => username, :password => password }) }.should raise_error(msg)
 end
 
-Given /^an ODataService exists with uri: "([^\"]*)" it should throw an exception with message "([^\"]*)"$/ do |uri, msg|  
-  lambda { @service = OData::Service.new(uri) }.should raise_error(msg)
+Given /^a HTTP BasicAuth ODataService exists it should throw an exception with message containing "([^\"]*)"$/ do |msg|  
+  lambda { @service = OData::Service.new(BASICAUTH_URL) }.should raise_error(/#{msg}.*/)
 end
 
-Given /^an ODataService exists with uri: "([^\"]*)" using self-signed certificate and username "([^\"]*)" and password "([^\"]*)"$/ do |uri, username, password|
-  @service = OData::Service.new(uri, { :username => username, :password => password, :verify_ssl => false })
+Given /^a HTTPS BasicAuth ODataService exists it should throw an exception with message containing "([^"]*)"$/ do |msg|
+  lambda { @service = OData::Service.new(HTTPS_BASICAUTH_URL) }.should raise_error(/#{msg}.*/)
+end
+
+Given /^a HTTP BasicAuth ODataService exists it should throw an exception with message "([^\"]*)"$/ do |msg|  
+  lambda { @service = OData::Service.new(BASICAUTH_URL) }.should raise_error(msg)
+end
+
+Given /^a HTTPS BasicAuth ODataService exists using self-signed certificate and username "([^\"]*)" and password "([^\"]*)"$/ do |username, password|
+  @service = OData::Service.new(HTTPS_BASICAUTH_URL, { :username => username, :password => password, :verify_ssl => false })
 end
 
 When /^I call "([^\"]*)" on the service$/ do |method|
@@ -31,7 +55,11 @@ When /^I call "([^\"]*)" on the service$/ do |method|
 end
 
 Then /^the result should be "([^\"]*)"$/ do |result|
-  @service_result.should == result 
+  @service_result.should eq result 
+end
+
+Then /^the integer result should be ([^\"]*)$/ do |result|
+  @service_result.should eq result.to_i
 end
 
 Then /^I should be able to call "([^\"]*)" on the service$/ do |method|
@@ -55,19 +83,19 @@ When /^I run the query$/ do
 end
 
 Then /^the result should be of type "([^\"]*)"$/ do |type|
-  @service_result.class.to_s.should == type
+  @service_result.class.to_s.should eq type
 end
 
 Then /^the result should have a method: "([^\"]*)"$/ do |method|
-  @service_result.respond_to?(method.to_sym).should == true
+  @service_result.respond_to?(method.to_sym).should eq true
 end
 
 Then /^the method "([^\"]*)" on the result should equal: "([^\"]*)"$/ do |method, value|
-  @service_result.send(method.to_sym).to_s.should == value
+  @service_result.send(method.to_sym).to_s.should eq value
 end
 
 Then /^the method "([^\"]*)" on the result should be nil$/ do |method|
-  @service_result.send(method.to_sym).should == nil
+  @service_result.send(method.to_sym).should eq nil
 end
 
 When /^I set "([^\"]*)" on the result to "([^\"]*)"$/ do |property_name, value|
@@ -94,27 +122,17 @@ When /^I ask for the top (\d+)$/ do |top|
   @service_query.top(top)
 end
 
+When /^I ask for the links for "([^\"]*)"$/ do |nav_prop|
+  @service_query.links(nav_prop)
+end
+
 Then /^the method "([^\"]*)" on the result should be of type "([^\"]*)"$/ do |method, type|
   result = @service_result.send(method.to_sym) 
-  result.class.to_s.should == type
+  result.class.to_s.should eq type
 end
 
 Given /^I call "([^\"]*)" on the service with a new "([^\"]*)" object(?: with (.*))?$/ do |method, object, fields|
-  fields_hash = {}
-  
-  if !fields.nil?
-    fields.split(', ').each do |field|
-      if field =~ /^(?:(\w+): "(.*)")$/
-        key = $1
-        val = $2
-        if val =~ /^@@LastSave$/
-          val = @saved_result
-        end
-        
-        fields_hash.merge!({ key => val })
-      end
-    end	
-  end
+  fields_hash = parse_fields_string(fields)
   
   obj = object.constantize.send(:make, fields_hash)
   @service.send(method.to_sym, obj)
@@ -125,7 +143,7 @@ When /^I save changes$/ do
 end
 
 Then /^the save result should be of type "([^\"]*)"$/ do |type|
-  @saved_result.class.to_s.should == type
+  @saved_result.class.to_s.should eq type
 end
 
 When /^I call "([^\"]*)" on the service with the last save result$/ do |method|
@@ -137,12 +155,12 @@ When /^I call "([^\"]*)" on the service with the last query result$/ do |method|
 end
 
 Then /^the save result should equal: "([^\"]*)"$/ do |result|
-  @saved_result.to_s.should == result
+  @saved_result.to_s.should eq result
 end
 
 Then /^the method "([^\"]*)" on the save result should equal: "([^\"]*)"$/ do |method, value|
   result = @saved_result.send(method.to_sym)
-  result.should == value
+  result.should eq value
 end
 
 When /^blueprints exist for the service$/ do
@@ -157,26 +175,14 @@ end
 Then /^no "([^\"]*)" should exist$/ do |collection|
   @service.send(collection)
   results = @service.execute
-  results.should == []
+  results.should eq []
 end
 
-Given /^the following (.*) exist:$/ do |plural_factory, table|
+Then /^the primitive results should be:$/ do |table|
   # table is a Cucumber::Ast::Table
-  factory = plural_factory.singularize
-  table.hashes.map do |hash|
-    obj = factory.constantize.send(:make, hash)
-    @service.send("AddTo#{plural_factory}", obj)
-    @service.save_changes
-  end
-end
-
-Given /^(\d+) (.*) exist$/ do |num, plural_factory|
-  factory = plural_factory.singularize
-  num.to_i.times do 
-    obj = factory.constantize.send(:make)
-    @service.send("AddTo#{plural_factory}", obj)
-  end
-  @service.save_changes # Batch save
+  values = table.hashes  
+  result_table = Cucumber::Ast::Table.new(values)
+  table.diff!(result_table)
 end
 
 Then /^the result should be:$/ do |table|
@@ -197,7 +203,7 @@ Then /^the result should be:$/ do |table|
   
   result_table = Cucumber::Ast::Table.new(results)
   
-  table.diff!(result_table) 	
+  table.diff!(result_table)
 end
 
 Then /^the save result should be:$/ do |table|
@@ -222,7 +228,7 @@ Then /^the save result should be:$/ do |table|
 end
 
 Then /^a class named "([^\"]*)" should exist$/ do |klass_name|
-  (Object.const_defined? klass_name).should == true
+  (Object.const_defined? klass_name).should eq true
 end
 
 # Operations against a method on the service result
@@ -232,13 +238,12 @@ When /^I call "([^\"]*)" for "([^\"]*)" on the result$/ do |method2, method1|
 end
 
 Then /^the operation should not be null$/ do
-  @operation_result.nil?.should == false
+  @operation_result.nil?.should eq false
 end
 
-
 Then /^the method "([^\"]*)" on the result's method "([^\"]*)" should equal: "([^\"]*)"$/ do |method, result_method, value|
   obj = @service_result.send(result_method.to_sym)
-  obj.send(method.to_sym).to_s.should == value
+  obj.send(method.to_sym).to_s.should eq value
 end
 
 When /^I set "([^\"]*)" on the result's method "([^\"]*)" to "([^\"]*)"$/ do |property_name, result_method, value|
@@ -249,20 +254,49 @@ end
 Then /^the "([^\"]*)" method should return a (.*)/ do |method_name, type|
   methods = method_name.split '.'
   if methods.length == 1
-    @service_result.send(method_name).class.to_s.should == type
+    @service_result.send(method_name).class.to_s.should eq type
   else
-    @service_result.send(methods[0]).send(methods[1]).class.to_s.should == type
+    @service_result.send(methods[0]).send(methods[1]).class.to_s.should eq type
+  end
+end
+Then /^the "([^\"]*)" method on the object should return a (.*)/ do |method_name, type|
+  methods = method_name.split '.'
+  if methods.length == 1
+    @service_result.first.send(method_name).class.to_s.should eq type
+  else
+    @service_result.first.send(methods[0]).send(methods[1]).class.to_s.should eq type
   end
-
 end
+
 Then /^I store the last query result for comparison$/ do
   @stored_query_result = @service_result
 end
+
 Then /^the new query result's time "([^\"]*)" should equal the saved query result$/ do |method_name|
   methods = method_name.split '.'
   if methods.length == 1
-    @service_result.send(method_name).xmlschema(3).should == @stored_query_result.send(method_name).xmlschema(3)
+    @service_result.send(method_name).xmlschema(3).should eq @stored_query_result.send(method_name).xmlschema(3)
+  else
+    @service_result.send(methods[0]).send(methods[1]).xmlschema(3).should eq @stored_query_result.send(methods[0]).send(methods[1]).xmlschema(3)
+  end
+end
+
+Then /^show me the results$/ do
+  puts @service_result
+end
+
+Then /^the result count should be (\d+)$/ do |expected_count|
+  @service_result.count.should eq expected_count.to_i
+end
+
+When /^I add a link between #{capture_model} and #{capture_model} on "([^"]*)"$/ do |parent, child, property|
+  @service.add_link(created_model(parent), property, created_model(child))
+end
+
+Given /^I call the service method "([^"]*)"(?: with (.*))?$/ do |method, args|
+  if args
+    @service_result = @service.send(method, args)
   else
-    @service_result.send(methods[0]).send(methods[1]).xmlschema(3).should == @stored_query_result.send(methods[0]).send(methods[1]).xmlschema(3)
+    @service_result = @service.send(method)
   end
 end