wcc-data 0.3.2 → 0.4.0.pre.pre.2

data/spec/wcc/data/response_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-describe WCC::Data::Response do
-  let(:unit) { WCC::Data::Response }
-  let(:raw) { double(:faraday_response) }
-  subject { unit.new(raw) }
-
-  describe "#initialize" do
-    it "takes a Faraday response object and sets it to @raw" do
-      expect(subject.raw).to eq(raw)
-    end
-  end
-
-  describe "method delegation" do
-    it "delegates `body` to @raw" do
-      expect(raw).to receive(:body).and_return(:value)
-      expect(subject.body).to eq(:value)
-      expect(subject.respond_to?(:body)).to be_truthy
-    end
-
-    it "delegates `headers` to @raw" do
-      expect(raw).to receive(:headers).and_return(:value)
-      expect(subject.headers).to eq(:value)
-      expect(subject.respond_to?(:headers)).to be_truthy
-    end
-
-    it "delegates `status` to @raw" do
-      expect(raw).to receive(:status).and_return(:value)
-      expect(subject.status).to eq(:value)
-      expect(subject.respond_to?(:status)).to be_truthy
-    end
-
-    it "delegates `success?` to @raw" do
-      expect(raw).to receive(:success?).and_return(:value)
-      expect(subject.success?).to eq(:value)
-      expect(subject.respond_to?(:success?)).to be_truthy
-    end
-  end
-
-  describe "#json" do
-    it "returns JSON deserialized body" do
-      expect(raw).to receive(:body) {
-        %[{"name":"Bob","interests":["Fishing","Rowing","Golfing"]}]
-      }
-      expect(subject.json).to eq({
-        "name" => "Bob",
-        "interests" => ["Fishing", "Rowing", "Golfing"],
-      })
-    end
-
-    it "returns nil if body is not valid JSON" do
-      expect(raw).to receive(:body) { "" }
-      expect(subject.json).to be_nil
-    end
-  end
-
-end

data/spec/wcc/data/rest_endpoint_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-describe WCC::Data::RESTEndpoint do
-  let(:service) { WCC::Data::Service.new }
-  subject { described_class.new(service: service) }
-
-  describe "#initialize" do
-    subject { described_class }
-    it "sets @service from :service option" do
-      obj = subject.new(service: service)
-      expect(obj.service).to eq(service)
-    end
-  end
-
-  shared_examples_for :rest_method_general_options do |method, verb, args|
-    let(:test_args) {
-      { foo: "bar", baz: "bing" }
-    }
-    it "takes a hash as last argument and passes to underlying service" do
-      args = Array(args)
-      expect(service).to receive(verb).with(hash_including(test_args))
-      subject.public_send(method, *args, test_args)
-    end
-  end
-
-  describe "#index" do
-    it_behaves_like :rest_method_general_options, :index, :get
-
-    it "calls #get directly on service" do
-      expect(service).to receive(:get).and_return("hi there")
-      expect(subject.index).to eq("hi there")
-    end
-  end
-
-  describe "#show" do
-    it_behaves_like :rest_method_general_options, :show, :get, 1
-
-    it "calls #get on service adding the id param to the URI" do
-      expect(service).to receive(:get).with(uri: "123").and_return("yo")
-      expect(subject.show(123)).to eq("yo")
-    end
-  end
-
-  describe "#create" do
-    it_behaves_like :rest_method_general_options, :create, :post, { test: 1 }
-
-    it "calls #post on service with attrs hash as body" do
-      expect(service).to receive(:post).with(body: { foo: "bar" }).and_return("hey bra")
-      expect(subject.create(foo: "bar")).to eq("hey bra")
-    end
-  end
-
-  describe "#update" do
-    it_behaves_like :rest_method_general_options, :update, :patch, [1, { test: 1 }]
-
-    it "calls #patch on service with id as URI and attrs as body" do
-      expect(service).to receive(:patch).with(uri: "123", body: {}).and_return("sup")
-      expect(subject.update(123, {})).to eq("sup")
-    end
-  end
-
-  describe "#destroy" do
-    it_behaves_like :rest_method_general_options, :destroy, :delete, 1
-
-    it "calls #delete on service with id as URI" do
-      expect(service).to receive(:delete).with(uri: "123").and_return("oh noes!")
-      expect(subject.destroy(123)).to eq("oh noes!")
-    end
-  end
-
-end

data/spec/wcc/data/service_spec.rb

@@ -1,128 +0,0 @@
-require 'spec_helper'
-
-describe WCC::Data::Service do
-  let(:unit) { WCC::Data::Service }
-  let(:connection) { double() }
-  let(:default_args) {
-    {
-      uri: "http://test.com/foo/",
-      connection: connection,
-    }
-  }
-  subject { unit.new(default_args) }
-
-  describe "#initialize" do
-    it "sets :uri to @uri" do
-      expect(subject.uri).to eq(URI(default_args[:uri]))
-    end
-
-    it "sets :connection to @connection" do
-      expect(subject.connection).to eq(default_args[:connection])
-    end
-  end
-
-  describe "#merge" do
-    it "returns a new instance" do
-      merged = subject.merge
-      expect(merged).to be_a(unit)
-      expect(merged.object_id).to_not eq(subject.object_id)
-    end
-
-    it "merges the URI params" do
-      merged = subject.merge(uri: "bar/baz?query")
-      expect(merged.uri.path).to eq("/foo/bar/baz")
-      expect(merged.uri.query).to eq("query")
-    end
-
-    it "sets to the right instance's @connection" do
-      connection = :bar
-      merged = subject.merge(connection: connection)
-      expect(merged.connection).to eq(connection)
-    end
-
-    it "accepts a hash of arguments as well as an instance" do
-      right = unit.new(uri: "bar", connection: double())
-      merged = subject.merge(right)
-      expect(merged.uri).to eq(URI("http://test.com/foo/bar"))
-      expect(merged.connection).to eq(right.connection)
-    end
-
-  end
-
-  shared_examples_for :http_verb_methods do
-    it "request verb matches the method name" do
-      expect(connection).to receive(:run_request) do |verb, _, _, _|
-        expect(verb).to eq(method)
-      end
-      subject.send(method, {})
-    end
-
-    it "returns a WCC::Data::Response instance" do
-      expect(connection).to receive(:run_request) {}
-      expect(subject.send(method, {})).to be_a(WCC::Data::Response)
-    end
-
-    it "merges :uri arg onto @uri" do
-      expect(connection).to receive(:run_request) do |_, url, _, _|
-        expect(url).to eq(URI("http://test.com/foo/bar"))
-      end
-      subject.send(method, uri: "bar")
-    end
-
-    it "sets the request body with :body arg" do
-      expect(connection).to receive(:run_request) do |_, _, body, _|
-        expect(body).to eq("a string")
-      end
-      subject.send(method, body: "a string")
-    end
-
-    it "provides request headers with :headers arg" do
-      expect(connection).to receive(:run_request) do |_, _, _, headers|
-        expect(headers).to eq(:foo)
-      end
-      subject.send(method, headers: :foo)
-    end
-
-    it "updates the params on the request if :params argument provided" do
-      params = { foo: "bar" }
-      request = double(params: double(:params))
-      expect(connection).to receive(:run_request).and_yield(request)
-
-      expect(request.params).to receive(:update).with(params)
-      subject.send(method, params: params)
-    end
-
-    it "does not update the params on the request if :params is nil" do
-      request = double(params: double(:params))
-      expect(connection).to receive(:run_request).and_yield(request)
-      expect(request.params).to_not receive(:update)
-      subject.send(method, {})
-    end
-  end
-
-  describe "#get" do
-    let(:method) { :get }
-    it_behaves_like :http_verb_methods
-  end
-
-  describe "#post" do
-    let(:method) { :post }
-    it_behaves_like :http_verb_methods
-  end
-
-  describe "#put" do
-    let(:method) { :put }
-    it_behaves_like :http_verb_methods
-  end
-
-  describe "#patch" do
-    let(:method) { :patch }
-    it_behaves_like :http_verb_methods
-  end
-
-  describe "#delete" do
-    let(:method) { :delete }
-    it_behaves_like :http_verb_methods
-  end
-
-end

data/spec/wcc/data_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe WCC::Data do
-
-  describe "::config" do
-    it "returns a cached instance of Config" do
-      config = WCC::Data.config
-      expect(config).to be_a(WCC::Data::Config)
-      expect(WCC::Data.config).to eq(config)
-    end
-  end
-
-  describe "::setup" do
-    it "yields to the provided block with config" do
-      config = WCC::Data.config
-      called = false
-      WCC::Data.setup do |passed_config|
-        called = true
-        expect(passed_config).to eq(config)
-      end
-      expect(called).to be_truthy
-    end
-  end
-
-end