frenchy 0.0.9 → 0.2.1

data/spec/lib/frenchy/collection_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+class MyModel
+  include Frenchy::Model
+end
+
+class MyModelDecorator
+  def self.decorate_collection(collection, options={})
+    return "DECORATED"
+  end
+end
+
+describe Frenchy::Collection do
+  describe "#decorate" do
+    describe "when there are no items" do
+      it "returns an empty array" do
+        coll = Frenchy::Collection.new
+        expect(coll.decorate).to eql([])
+      end
+    end
+
+    describe "when there are model items" do
+      it "decorates using the named convention" do
+        m1 = MyModel.new
+        m2 = MyModel.new
+        coll = Frenchy::Collection.new([m1, m2])
+        expect(coll.decorate).to eql("DECORATED")
+      end
+
+      it "supports a hash of options" do
+        m1 = MyModel.new
+        m2 = MyModel.new
+        coll = Frenchy::Collection.new([m1, m2])
+        expect(coll.decorate({"a" => 1})).to eq("DECORATED") # test arity
+      end
+    end
+  end
+end

data/spec/lib/frenchy/core_ext_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+class MyOtherClass
+  include Frenchy::Model
+end
+
+class MyClass
+  include Frenchy::Model
+
+  field :other, type: "my_other_class"
+end
+
+describe Hash do
+  describe "#stringify_keys" do
+    it "converts symbol keyed has to string keyed" do
+      expect({a: 1, b: 2}.stringify_keys!).to eql({"a" => 1, "b" => 2})
+    end
+  end
+end
+
+describe String do
+  describe "#constantize" do
+    it "properly constantizes a string" do
+      expect("MyClass".constantize).to eql(MyClass)
+    end
+  end
+
+  describe "#camelize" do
+    it "converts under_score to CamelCase" do
+      expect("my_class".camelize).to eql("MyClass")
+      expect("just_a_model".camelize).to eql("JustAModel")
+    end
+  end
+
+  describe "#underscore" do
+    it "converts CamelCase to under_score" do
+      expect("MyClass".underscore).to eql("my_class")
+      expect("JustAModel".underscore).to eql("just_a_model")
+    end
+  end
+end
+

data/spec/lib/frenchy/error_spec.rb

@@ -0,0 +1,69 @@
+require "spec_helper"
+
+describe Frenchy::RequestError do
+  describe "#message" do
+    describe "with an exception" do
+      it "uses the message from the exception" do
+        ex = EOFError.new("reached eof")
+        error = Frenchy::RequestError.new(ex.message)
+
+        message = begin
+          raise(error, ex)
+        rescue => e
+          e.message
+        end
+
+        expect(message).to eql("reached eof")
+      end
+
+      it "can be raised" do
+        ex = EOFError.new("reached eof")
+        error = Frenchy::RequestError
+        expect do
+          raise(error, ex)
+        end.to raise_error(Frenchy::RequestError, "reached eof")
+      end
+    end
+
+    describe "with a response" do
+      it "uses the status of the response" do
+        response = instance_double("Net::HTTPResponse", code: "500", body: "internal server error")
+        error = Frenchy::RequestError.new(nil, nil, response)
+
+        message = begin
+          raise(error)
+        rescue => e
+          e.message
+        end
+
+        expect(message).to include("500")
+        expect(message).to include("internal server error")
+      end
+
+      it "can be raised" do
+        response = instance_double("Net::HTTPResponse", code: "500", body: "internal server error")
+        error = Frenchy::RequestError.new(nil, response)
+        expect do
+          raise error, "something"
+        end.to raise_error(Frenchy::RequestError)
+      end
+    end
+  end
+
+  describe "#request" do
+    it "contains the original request" do
+      request = "GET https://api.github.com"
+      error = Frenchy::RequestError.new(nil, request, nil)
+      expect(error.request).to eql(request)
+    end
+  end
+
+  describe "#response" do
+    it "contains the original response" do
+      response = instance_double("Net::HTTPResponse", code: "500", body: "internal server error")
+      error = Frenchy::RequestError.new(nil, nil, response)
+      expect(error.response).to eql(response)
+    end
+  end
+
+end

data/spec/lib/frenchy/model_spec.rb

@@ -0,0 +1,213 @@
+require "spec_helper"
+
+class SimpleModel
+  include Frenchy::Model
+
+  field :id, type: "integer"
+  field :name, type: "string", default: "unknown"
+  field :occupation, type: "string"
+end
+
+class SpecialItem
+  include Frenchy::Model
+
+  field :id, type: "integer"
+end
+
+class SuperSpecialItem
+  include Frenchy::Model
+
+  field :id, type: "integer"
+end
+
+class Box
+  include Frenchy::Model
+
+  key :name
+
+  field :id, type: "integer"
+  field :name, type: "string"
+  field :gpa, type: "float", aliases: [:grade, :grade_point_average]
+  field :happy, type: "bool"
+  field :birth, type: "time"
+  field :aliases, type: "array"
+  field :extras, type: "hash"
+
+  field :item, type: "special_item"
+  field :items, type: "special_item", many: true
+  field :special, type: "special_item", class_name: "SuperSpecialItem"
+end
+
+class SimpleModelDecorator
+  def self.decorate(object, options={})
+    "DECORATED"
+  end
+end
+
+describe Frenchy::Model do
+  describe "#initialize" do
+    it "assigns given attributes" do
+      model = SimpleModel.new(id: 1, name: "bob")
+      expect(model.id).to eq(1)
+      expect(model.name).to eq("bob")
+    end
+
+    it "assigns defaults when attributes are missing" do
+      model = SimpleModel.new(id: 1)
+      expect(model.name).to eq("unknown")
+    end
+  end
+
+  describe "#attributes" do
+    it "includes all attributes, present or not" do
+      model = SimpleModel.new(id: 1)
+      expect(model.attributes).to eq({"id" => 1, "name" => "unknown", "occupation" => nil})
+    end
+  end
+
+  describe "#decorate" do
+    it "decorates the model using the named convention" do
+      model = SimpleModel.new
+      expect(model.decorate).to eq("DECORATED")
+    end
+
+    it "supports a hash of options" do
+      model = SimpleModel.new
+      expect(model.decorate({"a" => 1})).to eq("DECORATED") # test arity
+    end
+  end
+
+  describe ".key" do
+    it "provides to_param method" do
+      m = Box.new(id: 5, name: "john")
+      expect(m.to_param).to eql("john")
+    end
+  end
+
+  describe ".field" do
+    describe "aliases" do
+      it "aliases fields" do
+        m = Box.new(gpa: 5.0)
+        expect(m.gpa).to eql(5.0)
+        expect(m.grade).to eql(5.0)
+        expect(m.grade_point_average).to eql(5.0)
+      end
+    end
+
+    describe "string" do
+      it "converts values to a String" do
+        expect(Box.new(name: 1234).name).to eql("1234")
+      end
+    end
+
+    describe "integer" do
+      it "converts values to an Integer" do
+        expect(Box.new(id: "1234").id).to eql(1234)
+      end
+
+      it "raises an error with invalid values" do
+        expect{Box.new(id: "a")}.to raise_error(ArgumentError)
+      end
+    end
+
+    describe "float" do
+      it "converts values to a Float" do
+        expect(Box.new(gpa: "1").gpa).to eql(1.0)
+      end
+
+      it "raises an error with invalid values" do
+        expect{Box.new(gpa: "a")}.to raise_error(ArgumentError)
+      end
+    end
+
+    describe "bool" do
+      it "converts truthy values to true" do
+        ["true", "1", 1, true].each do |v|
+          expect(Box.new(happy: v).happy).to eql(true)
+        end
+      end
+
+      it "converts non-truthy values to false" do
+        ["false", "0", 0, false].each do |v|
+          expect(Box.new(happy: v).happy).to eql(false)
+        end
+      end
+    end
+
+    describe "time" do
+      it "converts unix timestamps to DateTime" do
+        v = Box.new(birth: 1234567890).birth
+        expect(v.class).to eql(DateTime)
+        expect(v.to_time.to_i).to eql(1234567890)
+        expect(v.year).to eql(2009)
+      end
+
+      it "converts strings DateTime" do
+        dt = DateTime.new(2011,2,3,4,5,6)
+        v = Box.new(birth: dt.to_s).birth
+        expect(v.class).to eql(DateTime)
+        expect(v.to_time.to_i).to eql(1296705906)
+        expect(v.year).to eql(2011)
+      end
+    end
+
+    describe "array" do
+      it "defaults to []" do
+        v = Box.new.aliases
+        expect(v.class).to eql(Array)
+        expect(v).to eql([])
+      end
+
+      it "stores arrays as is" do
+        v = Box.new(aliases: ["chuck", "charles"]).aliases
+        expect(v).to eql(["chuck", "charles"])
+      end
+
+      it "wraps singualr values in an array" do
+        v = Box.new(aliases: "chuck").aliases
+        expect(v).to eql(["chuck"])
+      end
+    end
+
+    describe "hash" do
+      it "defaults to {}" do
+        v = Box.new.extras
+        expect(v.class).to eql(Hash)
+        expect(v).to eql({})
+      end
+
+      it "stores hashes as is" do
+        v = Box.new(extras: {"a" => 1, "b" => 2}).extras
+        expect(v).to eql({"a" => 1, "b" => 2})
+      end
+
+      it "converts nested array values to a hash" do
+        v = Box.new(extras: [["type", "person"], ["pet", "dog"]]).extras
+        expect(v).to eql({"type" => "person", "pet" => "dog"})
+      end
+    end
+
+    describe "model relationships" do
+      it "establishes single model relationships" do
+        v = Box.new(item: {id: 1}).item
+        expect(v).to be_an_instance_of(SpecialItem)
+        expect(v.id).to eql(1)
+      end
+
+      it "supports explicit class name" do
+        v = Box.new(special: {id: 1}).special
+        expect(v).to be_an_instance_of(SuperSpecialItem)
+        expect(v.id).to eql(1)
+      end
+
+      it "establishes many model relationships" do
+        v = Box.new(items: [{id: 1}, {id: 2}]).items
+        expect(v).to be_an_instance_of(Frenchy::Collection)
+        expect(v[0]).to be_an_instance_of(SpecialItem)
+        expect(v[0].id).to eql(1)
+        expect(v[1]).to be_an_instance_of(SpecialItem)
+        expect(v[1].id).to eql(2)
+      end
+    end
+  end
+end

data/spec/lib/frenchy/request_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe Frenchy::Request do
+  describe "path substitution" do
+    it "substitutes path parameters" do
+      request = Frenchy::Request.new("service", "get", "/v1/users/:id/:token", {"id" => 1234, "token" => "md5something"}, {})
+      expect(request.path).to eql("/v1/users/1234/md5something")
+    end
+
+    it "retains remaining parameters as query parameters" do
+      request = Frenchy::Request.new("service", "get", "/v1/users/:id", {"id" => 1234, "token" => "md5something"}, {})
+      expect(request.path).to eql("/v1/users/1234")
+      expect(request.params).to eql({"token" => "md5something"})
+    end
+
+    it "raises an error for missing path parameters" do
+      expect do
+        Frenchy::Request.new("service", "get", "/v1/users/:id/:token", {"id" => 1234}, {})
+      end.to raise_error(Frenchy::Error)
+    end
+  end
+end

data/spec/lib/frenchy/resource_spec.rb

@@ -0,0 +1,105 @@
+require "spec_helper"
+
+class Bin
+  include Frenchy::Model
+  include Frenchy::Resource
+
+  resource  service: "httpbin",
+            endpoints: {
+              default:  { method: "get", path: "/get" },
+              one:      { method: "get", path: "/get" },
+              many:     { method: "get", path: "/get" },
+              search:   { method: "get", path: "/get" },
+            }
+
+  field :args, type: "hash"
+  field :headers, type: "hash"
+  field :origin, type: "string"
+  field :url, type: "string"
+end
+
+class BinOneEndpoint
+  include Frenchy::Model
+  include Frenchy::Resource
+
+  resource  service: "httpbin", endpoint: { path: "/get" }
+
+  field :args, type: "hash"
+end
+
+class BinNoEndpoints
+  include Frenchy::Model
+  include Frenchy::Resource
+
+  resource service: "httpbin"
+
+  field :id, type: "string"
+end
+
+class BinArgs
+  include Frenchy::Model
+  include Frenchy::Resource
+
+  resource  service: "httpbin",
+            endpoints: {
+              nested:  { method: "get", path: "/get", nesting: "args" },
+            }
+
+  field :my_arg, type: "string"
+end
+
+describe Frenchy::Resource do
+  before :all do
+    Frenchy.register_service("httpbin", {"host" => "http://httpbin.org"})
+  end
+
+  describe ".find" do
+    it "finds a single object with a single string parameter (id substitution)" do
+      resp = Bin.find("a")
+      expect(resp.args["id"]).to eql("a")
+    end
+
+    it "finds a single object with a parameters hash" do
+      resp = Bin.find(id: "a")
+      expect(resp.args["id"]).to eql("a")
+    end
+  end
+
+  describe ".find_one" do
+    it "finds a single object with id" do
+      resp = Bin.find_one("a")
+      expect(resp.args["id"]).to eql("a")
+    end
+  end
+
+  describe ".find_many" do
+    it "finds many objects with ids" do
+      resp = Bin.find_many(["a", "b", "c"])
+      expect(resp.args["ids"]).to eql("a,b,c")
+    end
+  end
+
+  describe ".find_with_endpoint" do
+    it "finds a single object with endpoint and params" do
+      resp = Bin.find_with_endpoint(:default, a: 1, b: 2)
+      expect(resp.args).to eql({"a" => "1", "b" => "2"})
+    end
+
+    it "finds a single object with a single endpoint and params" do
+      resp = BinOneEndpoint.find_with_endpoint(:default, a: 1, b: 2)
+      expect(resp.args).to eql({"a" => "1", "b" => "2"})
+    end
+
+    it "finds a single object with a nested endpoint and params" do
+      resp = BinArgs.find_with_endpoint(:nested, my_arg: "dataz")
+      expect(resp).to be_an_instance_of(BinArgs)
+      expect(resp.my_arg).to eql("dataz")
+    end
+
+    it "raises an exception if there are no endpoints" do
+      expect do
+        BinNoEndpoints.find_with_endpoint(:nonexist, myarg: "mydata")
+      end.to raise_exception(Frenchy::Error)
+    end
+  end
+end