lexile 0.0.2

data/lib/lexile.rb

@@ -0,0 +1,22 @@
+require 'json'
+require 'hashie/mash'
+require 'httparty'
+
+require 'lexile/configuration'
+require 'lexile/version'
+require 'lexile/api/client'
+require 'lexile/errors'
+
+# Data Models
+require 'lexile/model'
+require 'lexile/book'
+
+#API Operations
+require 'lexile/api/resource'
+require 'lexile/api/books'
+require 'lexile/api/endpoints'
+
+module Lexile
+  extend Configuration
+  extend Api::Endpoints
+end

data/spec/lexile/api/books_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe Lexile::Api::Books,  :vcr => { :cassette_name => "books" } do
+
+  before { set_testing_configuration }
+
+
+  context '#show' do
+    let(:book){ Lexile.books.show(lexile_book_id) }
+
+    it "should return result" do
+      expect(book).to_not be_nil
+    end
+
+    it 'should be book' do
+      expect(book).to be_an_instance_of( Lexile::Book )
+    end
+
+    it 'should have id key' do
+      expect(book).to respond_to(:id)
+    end
+
+    it 'should have lexile key' do
+      expect(book).to respond_to(:lexile)
+    end
+
+    it 'should have lexile_display key' do
+      expect(book).to respond_to(:lexile_display)
+    end
+
+    it 'should have pages key' do
+      expect(book).to respond_to(:pages)
+    end
+  end
+
+  context '#find_by_isbn13' do
+    let(:books){ Lexile.books.find_by_isbn13(lexile_book_isbn13) }
+
+    it "should return not empty array" do
+      expect(books).to_not be_nil
+    end
+
+    it 'should be array' do
+      expect(books).to be_an_instance_of( Array )
+    end
+
+    it 'length should be > 0' do
+      expect(books.length).to_not be_zero
+    end
+
+    it 'should be array of Lexile::Book' do
+      books.each do |book|
+        expect(book).to be_an_instance_of( Lexile::Book )
+      end
+    end
+
+    it 'should have id key' do
+      expect(books[0]).to respond_to(:id)
+    end
+
+    it 'should have lexile key' do
+      expect(books[0]).to respond_to(:lexile)
+    end
+
+    it 'should have lexile_display key' do
+      expect(books[0]).to respond_to(:lexile_display)
+    end
+
+    it 'should have pages key' do
+      expect(books[0]).to respond_to(:pages)
+    end
+  end
+
+  context '#find_by_title' do
+     let(:books){ Lexile.books.find_by_title(lexile_book_title) }
+
+     it "should return not empty array" do
+       expect(books).to_not be_nil
+     end
+
+     it 'should be array' do
+       expect(books).to be_an_instance_of( Array )
+     end
+
+     it 'length should be > 0' do
+       expect(books.length).to_not be_zero
+     end
+
+     it 'should be array of Lexile::Book' do
+       books.each do |book|
+         expect(book).to be_an_instance_of( Lexile::Book )
+       end
+     end
+
+     it 'should have id key' do
+       expect(books[0]).to respond_to(:id)
+     end
+
+     it 'should have lexile key' do
+       expect(books[0]).to respond_to(:lexile)
+     end
+
+     it 'should have lexile_display key' do
+       expect(books[0]).to respond_to(:lexile_display)
+     end
+
+     it 'should have pages key' do
+       expect(books[0]).to respond_to(:pages)
+     end
+   end
+
+
+end

data/spec/lexile/api/client_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Lexile::API::Client do
+
+  let(:client){
+    set_testing_configuration
+    Lexile::API::Client.new( Lexile )
+  }
+
+  it "should have a VERSION" do
+    Lexile::VERSION.should_not be_nil
+  end
+
+  describe 'initialization' do
+    describe 'via configure' do
+      context "should be initialized by config" do
+        before do
+          set_testing_configuration
+          @cli = Lexile.configure do |c |
+                c.username  = lexile_username
+                c.password  = lexile_password
+                c.testing   = true
+          end
+          @options_hash = @cli.class.default_options
+        end
+
+        it { expect(@cli).to_not be_nil }
+        it { expect(@options_hash[:base_uri]).to eq Lexile.api_url }
+        it { expect(@options_hash[:default_params]).to be_nil }
+        it { expect(@options_hash[:debug_output]).to_not be_nil }
+        it { expect(@options_hash[:headers]).to_not be_nil }
+        it { expect(@options_hash[:headers]['User-Agent']).to_not be_nil }
+      end
+    end
+
+    context 'should be initialized via hash' do
+      before do
+        configuration_hash = {
+            endpoint:     'https://example.com',
+            api_version:  'v52',
+            username:     'my_lexile_username',
+            password:     'my_lexile_password',
+            testing:      true
+        }
+        @options_hash = client.class.default_options
+        @client = Lexile::API::Client.new( configuration_hash )
+      end
+
+      it{ expect(@client).to_not be_nil }
+      it{ expect(@options_hash[:base_uri]).to eq 'https://example.com/v52' }
+      it{ expect(@options_hash[:default_params]).to be_nil }
+      it{ expect(@options_hash[:debug_output]).to_not be_nil }
+    end
+  end
+
+  describe "get" do
+    it "should not raise an exception with response status 200" do
+      VCR.use_cassette("errors") do
+        expect{ client.get("/book") }.not_to raise_error
+      end
+    end
+
+
+    it "should raise Lexile::AuthenticationFailed with response status is 401" do
+          VCR.use_cassette("errors") do
+            expect{ client.get("/401") }.to raise_error  Lexile::AuthenticationFailed
+          end
+    end
+
+
+    it "should raise Lexile::NotFound with response status is 404" do
+      VCR.use_cassette("errors") do
+        expect{ client.get("/404") }.to raise_error  Lexile::NotFound
+      end
+    end
+
+
+
+    [
+      {status: 400, ex: Lexile::BadRequest },
+      {status: 401, ex: Lexile::AuthenticationFailed},
+      {status: 404, ex: Lexile::NotFound},
+      {status: 500, ex: Lexile::ServerError},
+      {status: 502, ex: Lexile::Unavailable},
+      {status: 503, ex: Lexile::RateLimited},
+      {status: 504, ex: Lexile::RateLimited},
+      {status: 999, ex: Lexile::UnknownStatusCode}
+    ].each do |test_args|
+      it "should raise #{test_args[:ex].name} when status code is #{test_args[:status]}" do
+        client.class.stub(:get){ mock = double; mock.stub(:code){test_args[:status]}; mock }
+        expect{
+          client.get("/something")
+        }.to raise_error test_args[:ex]
+      end
+    end
+  end
+end

data/spec/lexile/configuration_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Lexile::Configuration do
+
+  before do
+    set_testing_configuration
+  end
+
+  describe '.configure' do
+    Lexile::Configuration::VALID_CONFIG_KEYS.each do |key|
+      it "should set the #{key}" do
+        Lexile.configure do |config|
+          if key == :timeout
+            config.send("#{key}=", 10)
+            expect(Lexile.send(key)).to eq 10
+          else
+            config.send("#{key}=", key)
+            expect(Lexile.send(key)).to eq key
+          end
+        end
+      end
+    end
+    it "should configure the client with this configuration" do
+      client = Lexile.configure do |config|
+        config.api_version = "V74_5_5"
+      end
+      client.should_not be_nil
+      client.class.default_options[:base_uri].should match /V74_5_5/
+    end
+
+    it "should return a cliend configured with this configuration" do
+        client = Lexile.configure do |config|
+          config.api_version = "V74_5_5"
+        end
+        client = Lexile.send(:client)
+        client.should_not be_nil
+        client.class.default_options[:base_uri].should match /V74_5_5/
+    end
+  end
+
+  describe "default values" do
+    before{ Lexile.reset! }
+    Lexile::Configuration::VALID_CONFIG_KEYS.each do |key|
+      describe ".#{key}" do
+        it 'should return the default value' do
+          expect(Lexile.send(key)).to eq Lexile::Configuration.const_get("DEFAULT_#{key.upcase}")
+        end
+      end
+    end
+  end
+end

data/spec/lexile/errors_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Lexile::HTTPError do
+  let(:response){
+    mock_response = double()
+    mock_response.stub(:code){ 259 }
+    mock_response.stub(:body){"<html><head></head><body>Hello World!</body></html>"}
+    mock_response
+  }
+
+  subject{ Lexile::HTTPError.new( response )}
+
+  it "should format correctly as a string" do
+    subject.to_s.should match /Lexile::HTTPError/
+    subject.to_s.should match /259/
+    subject.to_s.should match /Hello World/
+  end
+end

data/spec/lexile/model_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Lexile::Model do
+
+
+  describe "#parse" do
+    # We will use a Lexile::Book which is a model to test model properties
+    let(:single_object_response){ { 'a' => 'ONE', 'b' => 'TWO', 'c' => 'THREE'} }
+    let(:multi_object_response){{ 'objects' =>[{ 'a' => 'ONE', 'b' => 'TWO', 'c' => 'THREE'},{ 'a' => 'UNO', 'b' => 'DOS', 'c' => 'TRES'},{ 'a' => 'UNE', 'b' => 'DEUX', 'c' => 'TROIS'}] }}
+    let(:invalid_json){ "{\"objects\":\"Most Definetly not an array of objects\"}" }
+
+    it "should raise an exception if a mult-object response does not contain an array" do
+      expect{
+        Lexile::Book.parse( invalid_json )
+      }.to raise_error Lexile::CannotProcessResponse, /is present in response but it does not contain an Array/
+    end
+
+    it "should parse a single object response" do
+      soj = Lexile::Book.parse( single_object_response.to_json )
+      single_object_response.each do |key|
+        soj[key].should eq single_object_response[key]
+      end
+    end
+
+    it "should parse a multi object response" do
+      books = Lexile::Book.parse( multi_object_response.to_json )
+      objs = multi_object_response['objects']
+      books.length.should eq objs.length
+      #deep compare of books
+      objs.each do |obj|
+        index = books.find_index{|book| book['a']== obj['a']}
+        index.should_not be_nil
+        book = books[index]
+        obj.each do |key|
+          book[key].should eq obj[key]
+        end
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require 'rspec'
+require 'vcr'
+require 'webmock/rspec'
+require 'hashie'
+require 'lexile'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+WebMock.disable_net_connect!
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'spec/vcr_tapes'
+  c.hook_into :webmock
+  c.configure_rspec_metadata!
+  c.default_cassette_options = {
+    #record:                      (ENV['TRAVIS'] ? :none : :once)
+    #record:                      :new_episodes
+    #record:                      :all
+    record:                      :none
+  }
+
+  c.ignore_hosts 'codeclimate.com'
+  c.filter_sensitive_data("<USERNAME>") { Lexile.options[:username] }
+  c.filter_sensitive_data("<PASSWORD>") { Lexile.options[:password] }
+end
+
+RSpec.configure do |config|
+  config.include LexileHelper
+  config.color = true
+  config.tty = true
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.order = "random"
+end

data/spec/support/lexile_helper.rb

@@ -0,0 +1,29 @@
+module LexileHelper
+  def set_testing_configuration
+    Lexile.reset!
+    Lexile.username  = lexile_username
+    Lexile.password  = lexile_password
+    Lexile.testing   = true
+  end
+
+  def lexile_username
+    'AUSERNAME'
+  end
+
+  def lexile_password
+    'APASSWORD'
+  end
+
+  def lexile_book_id
+    315833 #ISBN 9780062012722 Title: It Happened to Nancy: By An Anonymous Teenager: A True Story from Her Diary
+  end
+
+  def lexile_book_isbn13
+    9780062012722 #id: 315833  Title: It Happened to Nancy: By An Anonymous Teenager: A True Story from Her Diary
+  end
+
+  def lexile_book_title
+    "Malala"
+  end
+
+end