storify 0.0.13 → 0.0.14

data/spec/pager_spec.rb

@@ -1,85 +1,80 @@
 require 'spec_helper'
 
 describe Storify::Pager do
-  context "Page" do
-    it "should optionally accept a starting page" do
-      Storify::Pager.new(page: 10).page.should == 10
+  context ".page" do
+    it "optionally accepts a starting page" do
+      expect(Storify::Pager.new(page: 10).page).to eql 10
     end
 
-    it "should set the default starting page to 1" do
-      Storify::Pager.new.page.should == 1
+    it "sets the default starting page to 1" do
+      expect(Storify::Pager.new.page).to eql 1
     end
 
-    it "should limit the page to the API Min" do
-      pager = Storify::Pager.new(page: -1)
-      pager.page.should == Storify::Pager::MIN_PAGE
+    it "limits the page to the API minimum" do
+      expect(Storify::Pager.new(page: -1).page).to eql Storify::Pager::MIN_PAGE
     end
 
-    it "should optionally allow an artificial max page (inclusive)" do
-      pager = Storify::Pager.new(max: 20)
-      pager.max.should == 20
+    it "optionally allows an artificial max page (inclusive)" do
+      expect(Storify::Pager.new(max: 20).max).to eql 20
     end
 
-    it "should default the page max to unlimited (0)" do
-      pager = Storify::Pager.new
-      pager.max.should == 0
+    it "sets the default the page max to unlimited" do
+      expect(Storify::Pager.new.max).to eql 0
     end
 
-    it "should allow a page to be advanced (forward)" do
-      pager = Storify::Pager.new
-      pager.next.page.should == 2
+    it "allows a page to be advanced forward" do
+      expect(Storify::Pager.new.next.page).to eql 2
     end
 
-    it "should not allow a page to be advanced beyond (max + 1)" do
-      pager = Storify::Pager.new(max: 2)
-      pager.next.next.next.page.should == 3
+    it "does not allow a page to be advanced beyond max + 1" do
+      expect(Storify::Pager.new(max: 2).next.next.next.page).to eql 3
     end
 
-    it "should allow a page to be advanced (backward)" do
-      pager = Storify::Pager.new(page: 2)
-      pager.prev.prev.page.should == 1
+    it "allows a page to be advanced backward" do
+      expect(Storify::Pager.new(page: 2).prev.prev.page).to eql 1
     end
   end
 
-  context "Per Page" do
-    it "should optionally accept a per page option" do
-      Storify::Pager.new(per_page: 15).per_page.should == 15
+  context ".per_page" do
+    it "optionally accepts a per page option" do
+      expect(Storify::Pager.new(per_page: 15).per_page).to eql 15
     end
 
-    it "should set the default per_page to 20" do
-      Storify::Pager.new.per_page.should == 20
+    it "sets the default per_page to 20" do
+      expect(Storify::Pager.new.per_page).to eql 20
     end
 
-    it "should limit per_page to the API Max" do
-      # Constructor
-      pager = Storify::Pager.new(per_page: 100)
-      pager.per_page.should == Storify::Pager::MAX_PER_PAGE
+    it "limits per_page to the API maximum (constructor)" do
+      expect(Storify::Pager.new(per_page: 100).per_page).to eql Storify::Pager::MAX_PER_PAGE
+    end
 
-      # Setter
+    it "limits per_page to the API maximum (setter)" do
+      pager = Storify::Pager.new
       pager.per_page = 500
-      pager.per_page.should == Storify::Pager::MAX_PER_PAGE
+      expect(pager.per_page).to eql Storify::Pager::MAX_PER_PAGE
     end
   end
 
-  context "Utility" do
-    it "should provide access to pagnination as a parameter hash" do
+  context ".to_hash" do
+    it "hashifies pagination parameters" do
       pager = Storify::Pager.new(page: 13, per_page: 25).to_hash
-      pager[:page].should == 13
-      pager[:per_page].should == 25
+      expect(pager[:page]).to eql 13
+      expect(pager[:per_page]).to eql 25
     end
+  end
 
-    it "should know if there are pages left based on content array size" do
+  context ".has_pages?" do
+    it "knows if there are pages left based on content array size" do
       data = {'content' => {'stories' => ['s1', 's2', 's3']}}
       pager = Storify::Pager.new
-      pager.has_pages?(data['content']['stories']).should be_true
-      pager.has_pages?(data['content'][:invalid]).should be_false
-      pager.has_pages?([]).should be_false
+
+      expect(pager.has_pages?(data['content']['stories'])).to be_true
+      expect(pager.has_pages?(data['content'][:invalid])).to be_false
+      expect(pager.has_pages?([])).to be_false
     end
 
-    it "should have no pages left once on the final page" do
-      pager = Storify::Pager.new(max: 2)
-      pager.next.next.next
-      pager.has_pages?(['g']).should be_false
+    it "has no pages left once on the final page" do
+      expect(Storify::Pager.new(max: 2).next.next.next.has_pages?(['g'])).to be_false
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,27 +1,50 @@
-require 'storify'
+require 'webmock/rspec'
 require 'io/console'
+require 'storify'
+require 'vcr'
+require 'uri'
 
-RSpec.configure do |config|
-  config.mock_with :rspec
-  config.add_setting :api_key, :default => ''
-  config.add_setting :api_usr, :default => ''
+ENV['STORIFY_TOKEN'] = "mock__token"
+ENV['STORIFY_SECRET'] = "mock_secret"
+ENV['STORIFY_EMAIL'] = "mock_email"
+ENV['STORIFY_TOK'] = "mock_token"
+ENV['STORIFY_PASSWORD'] = "mock_password"
+ENV['STORIFY_USERNAME'] = "rtejpar"
+ENV['STORIFY_APIKEY'] = "mock_apikey"
 
-  # load user-specific keys or fallback to defaults
-  config.before(:all) do
-    begin
-      require File.dirname(__FILE__) + '/.userkey.rb'
-      @api_key = API_KEY
-      @username = USERNAME
-    rescue LoadError
-      @api_key = RSpec.configuration.api_key
-      @username = RSpec.configuration.api_usr
-    end
 
+RSpec.configure do |config|
+  config.before(:all) do
+    @api_key = ENV['STORIFY_APIKEY']
+    @username = ENV['STORIFY_USERNAME']
   end
 end
 
 def get_password
-  puts "Enter Storify Password:"
-  STDOUT.flush
-  STDIN.noecho(&:gets).chomp
+  ENV['STORIFY_PASSWORD']
+end
+
+def get_encoded_password
+  URI.encode_www_form_component(get_password)
+end
+
+VCR.configure do |config|
+  config.cassette_library_dir = 'fixtures/vcr_cassettes'
+  config.hook_into :webmock
+  config.filter_sensitive_data('mock__token') {ENV['STORIFY_TOKEN']}
+  config.filter_sensitive_data('mock_secret') {ENV['STORIFY_SECRET']}
+  config.filter_sensitive_data('mock_token') {ENV['STORIFY_TOK']}
+  config.filter_sensitive_data('mock_username') {ENV['STORIFY_USERNAME']}
+  config.filter_sensitive_data('mock_apikey') {ENV['STORIFY_APIKEY']}
+  config.filter_sensitive_data('mock_email') {ENV['STORIFY_EMAIL']}
+
+  config.filter_sensitive_data('mock_password') do |interaction|
+    get_encoded_password
+  end
+
+  config.default_cassette_options = { :record => :new_episodes, :match_requests_on => [:query, :uri, :method, :body] }
+end
+
+def vcr_ignore_protocol
+  [:host, :path, :method, :query, :body]
 end

data/spec/storify_spec.rb

@@ -1,146 +1,147 @@
 require 'spec_helper'
 
 describe Storify do
-  context "API Protocols:" do
-    it "should support http" do
-      Storify::PROTOCOLS[:insecure].should == "http://"
+  context "API Protocols" do
+    it "supports http" do
+      expect(Storify::PROTOCOLS[:insecure]).to eql "http://"
     end
 
-    it "should support secure http" do
-      Storify::PROTOCOLS[:secure].should == "https://"
+    it "supports secure http" do
+      expect(Storify::PROTOCOLS[:secure]).to eql "https://"
     end
 
-    it "should default to secure http" do
-      Storify::PROTOCOLS[:unknown].should == "https://"
+    it "defaults to secure http" do
+      expect(Storify::PROTOCOLS[:unknown]).to eql "https://"
     end
   end
 
-  context "API Versions:" do
-    it "should support Storify API v1" do
-      Storify::ENDPOINTS[:v1].is_a?(Hash).should be_true
+  context "API Versions" do
+    it "supports v1" do
+      expect(Storify::ENDPOINTS[:v1].is_a?(Hash)).to be_true
     end
 
-    it "should fallback to Storify API v1" do
-      Storify::ENDPOINTS[:unknown].is_a?(Hash).should be_true
+    it "defaults to v1" do
+      expect(Storify::ENDPOINTS[:unknown].is_a?(Hash)).to be_true
     end
   end
 
-  context "API v1 Endpoints Sub-Paths:" do
-    it "should support a base URL for a version" do
-      Storify::ENDPOINTS[:v1][:base].should == "api.storify.com/v1"
+  context "API Endpoints" do
+    it "supports a base URL for a version" do
+      expect(Storify::ENDPOINTS[:v1][:base]).to eql "api.storify.com/v1"
     end
 
-    it "should default to the base URL" do
-      Storify::ENDPOINTS[:unknown][:unknown].should == "api.storify.com/v1"
+    it "defaults to the base URL" do
+      expect(Storify::ENDPOINTS[:unknown][:unknown]).to eql "api.storify.com/v1"
     end
 
-    it "should support the Authentication endpoint" do
-      Storify::ENDPOINTS[:v1][:auth].should == "/auth"
+    it "supports Authentication" do
+      expect(Storify::ENDPOINTS[:v1][:auth]).to eql "/auth"
     end
 
-    it "should support the Stories endpoint" do
-      Storify::ENDPOINTS[:v1][:stories].should == "/stories"
+    it "supports Stories" do
+      expect(Storify::ENDPOINTS[:v1][:stories]).to eql "/stories"
     end
 
-    it "should support the Latest Stories endpoint" do
-      Storify::ENDPOINTS[:v1][:latest].should == "/stories/browse/latest"
+    it "supports Latest Stories" do
+      expect(Storify::ENDPOINTS[:v1][:latest]).to eql "/stories/browse/latest"
     end
 
-    it "should support the Featured Stories endpoint" do
-      Storify::ENDPOINTS[:v1][:featured].should == "/stories/browse/featured"
+    it "supports Featured Stories" do
+      expect(Storify::ENDPOINTS[:v1][:featured]).to eql "/stories/browse/featured"
     end
 
-    it "should support the Popular Stories endpoint" do
-      Storify::ENDPOINTS[:v1][:popular].should == "/stories/browse/popular"
+    it "supports Popular Stories" do
+      expect(Storify::ENDPOINTS[:v1][:popular]).to eql "/stories/browse/popular"
     end
 
-    it "should support Stories by Topic endpoint" do
-      Storify::ENDPOINTS[:v1][:topic].should == "/stories/browse/topic/:topic"
+    it "supports Stories by Topic" do
+      expect(Storify::ENDPOINTS[:v1][:topic]).to eql "/stories/browse/topic/:topic"
     end
 
-    it "should support the User Stories endpoint" do
-      Storify::ENDPOINTS[:v1][:userstories].should == "/stories/:username"
+    it "supports User Stories" do
+      expect(Storify::ENDPOINTS[:v1][:userstories]).to eql "/stories/:username"
     end
 
-    it "should support the Single Story endpoint" do
-      Storify::ENDPOINTS[:v1][:userstory].should == "/stories/:username/:slug"
+    it "supports a Single Story" do
+      expect(Storify::ENDPOINTS[:v1][:userstory]).to eql "/stories/:username/:slug"
     end
 
-    it "should support the Edit Story Slug endpoint" do
-      Storify::ENDPOINTS[:v1][:editslug].should == "/stories/:username/:slug/editslug"
+    it "supports Editing a Story Slug" do
+      expect(Storify::ENDPOINTS[:v1][:editslug]).to eql "/stories/:username/:slug/editslug"
     end
 
-    it "should support the Search Story endpoint" do
-      Storify::ENDPOINTS[:v1][:search].should == "/stories/search"
+    it "supports Searching for Stories" do
+      expect(Storify::ENDPOINTS[:v1][:search]).to eql "/stories/search"
     end
 
-    it "should support the Users endpoint" do
-      Storify::ENDPOINTS[:v1][:users].should == "/users"
+    it "supports Users" do
+      expect(Storify::ENDPOINTS[:v1][:users]).to eql "/users"
     end
 
-    it "should support the User Profile endpoint" do
-      Storify::ENDPOINTS[:v1][:userprofile].should == "/users/:username"
+    it "supports User Profiles" do
+      expect(Storify::ENDPOINTS[:v1][:userprofile]).to eql "/users/:username"
     end
 
-    it "should support the Publish Story endpoint" do
-      Storify::ENDPOINTS[:v1][:publish].should == "/stories/:username/:slug/publish"
+    it "supports Publishing a Story" do
+      expect(Storify::ENDPOINTS[:v1][:publish]).to eql "/stories/:username/:slug/publish"
     end
 
-    it "should support the Update User Profile endpoint" do
-      Storify::ENDPOINTS[:v1][:update_profile].should == "/users/:username/update"
+    it "supports Updating a User Profile" do
+      expect(Storify::ENDPOINTS[:v1][:update_profile]).to eql "/users/:username/update"
     end
 
-    it "should support the Save Story endpoint" do
-      Storify::ENDPOINTS[:v1][:save].should == "/stories/:username/:slug/save"
+    it "supports Saving a Story" do
+      expect(Storify::ENDPOINTS[:v1][:save]).to eql "/stories/:username/:slug/save"
     end
 
-    it "should support the Create Story endpoint" do
-      Storify::ENDPOINTS[:v1][:create].should == "/stories/:username/create"
+    it "supports Creating a Story" do
+      expect(Storify::ENDPOINTS[:v1][:create]).to eql "/stories/:username/create"
     end
 
-    it "should support the Delete Story endpoint (undocumented)" do
-      Storify::ENDPOINTS[:v1][:delete].should == "/stories/:username/:slug/delete"
+    it "supports Deleting a Story (undocumented)" do
+      expect(Storify::ENDPOINTS[:v1][:delete]).to eql "/stories/:username/:slug/delete"
     end
   end
 
-  context "API Endpoint URI Builder:" do
-    it "should allow dynamic protocol selection" do
-      Storify::endpoint(protocol: :secure).include?('https').should be_true
+  context "URI Builder" do
+    it "allows dynamic protocol selection" do
+      expect(Storify::endpoint(protocol: :secure).include?('https')).to be_true
     end
 
-    it "should allow dynamic version selection" do
-      Storify::endpoint(version: :v1).include?('v1').should be_true
+    it "allows dynamic version selection" do
+      expect(Storify::endpoint(version: :v1).include?('v1')).to be_true
     end
 
-    it "should allow dynamic endpoint selection" do
-      Storify::endpoint(method: :auth).include?('/auth').should be_true
+    it "allows dynamic endpoint selection" do
+      expect(Storify::endpoint(method: :auth).include?('/auth')).to be_true
     end
 
-    it "should allow dynamic parameter substitution" do
-      params = {':username' => 'rtejpar', ':slug' => 'this-is-my-story'}
+    it "allows dynamic parameter substitution" do
+      params = {':username' => 'uname', ':slug' => 'this-is-my-story'}
       uri = Storify::endpoint(params: params, method: :userstory)
-      ['rtejpar', 'this-is-my-story'].each {|s| uri.include?(s).should be_true }
+
+      ['uname', 'this-is-my-story'].each do |s|
+        expect(uri.include?(s)).to be_true
+      end
     end
 
-    it "should force secure protocol for Authentication" do
-      Storify::endpoint(protocol: :secure, method: :auth).include?('https').should be_true
+    it "enforces secure protocol for Authentication" do
+      expect(Storify::endpoint(protocol: :secure, method: :auth).include?('https')).to be_true
     end
 
-    it "should build the final uri based on dynamic configuration" do
-      params = {':username' => 'rtejpar'}
-      uri = Storify::endpoint(protocol: :insecure, method: :userstories, params: params)
-      uri.should == 'http://api.storify.com/v1/stories/rtejpar'
+    it "builds the final uri based on dynamic configuration" do
+      params = {':username' => 'uname'}
+      expect(Storify::endpoint(protocol: :insecure, method: :userstories, params: params)).to eql 'http://api.storify.com/v1/stories/uname'
     end
   end
 
-  context "API v1 Error Handling" do
-    it "should return an empty content block (if api max reached)" do
+  context "API Error Handling" do
+    it "returns an empty content block (if api max reached)" do
       eoc = Storify::Client::EOC
-      content = Storify::error(400, '...Max...', 'bad request', end_of_content: eoc)
-      content.should == eoc
+      expect(Storify::error(400, '...Max...', 'bad request', end_of_content: eoc)).to eql eoc
     end
 
-    it "should return an API error for a non-max case" do
+    it "raises an API error for a non-max case" do
       eoc = Storify::Client::EOC
       expect{Storify::error(400, '...', 'bad request', end_of_content: eoc)}.to raise_error(Storify::ApiError)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: storify
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - Rizwan Tejpar
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-16 00:00:00.000000000 Z
+date: 2013-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -80,6 +80,34 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.16.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.16.1
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.8'
 - !ruby/object:Gem::Dependency
   name: io-console
   requirement: !ruby/object:Gem::Requirement
@@ -134,15 +162,48 @@ files:
 - lib/storify/story.rb
 - lib/storify/storymeta.rb
 - lib/storify/storystats.rb
+- lib/storify/string.rb
 - lib/storify/user.rb
 - lib/storify/userstats.rb
 - lib/storify.rb
 - spec/client_auth_spec.rb
-- spec/client_noauth_spec.rb
+- spec/client_edit_slug_spec.rb
+- spec/client_profile_spec.rb
+- spec/client_profile_update_spec.rb
 - spec/client_spec.rb
+- spec/client_stories_featured_spec.rb
+- spec/client_stories_latest_spec.rb
+- spec/client_stories_popular_spec.rb
+- spec/client_stories_search_spec.rb
+- spec/client_stories_spec.rb
+- spec/client_stories_topic_spec.rb
+- spec/client_story_create_spec.rb
+- spec/client_story_delete_spec.rb
+- spec/client_story_publish_spec.rb
+- spec/client_story_save_spec.rb
+- spec/client_story_spec.rb
+- spec/client_users_spec.rb
+- spec/client_userstories_spec.rb
 - spec/pager_spec.rb
 - spec/spec_helper.rb
 - spec/storify_spec.rb
+- fixtures/vcr_cassettes/auth.yml
+- fixtures/vcr_cassettes/create.yml
+- fixtures/vcr_cassettes/delete.yml
+- fixtures/vcr_cassettes/edit_slug.yml
+- fixtures/vcr_cassettes/featured.yml
+- fixtures/vcr_cassettes/latest.yml
+- fixtures/vcr_cassettes/popular.yml
+- fixtures/vcr_cassettes/profile.yml
+- fixtures/vcr_cassettes/profile_update.yml
+- fixtures/vcr_cassettes/publish.yml
+- fixtures/vcr_cassettes/save.yml
+- fixtures/vcr_cassettes/search.yml
+- fixtures/vcr_cassettes/stories.yml
+- fixtures/vcr_cassettes/story.yml
+- fixtures/vcr_cassettes/topic.yml
+- fixtures/vcr_cassettes/users.yml
+- fixtures/vcr_cassettes/userstories.yml
 homepage: https://github.com/natural-affinity/storify
 licenses:
 - MIT
@@ -169,8 +230,40 @@ specification_version: 4
 summary: Storify API
 test_files:
 - spec/client_auth_spec.rb
-- spec/client_noauth_spec.rb
+- spec/client_edit_slug_spec.rb
+- spec/client_profile_spec.rb
+- spec/client_profile_update_spec.rb
 - spec/client_spec.rb
+- spec/client_stories_featured_spec.rb
+- spec/client_stories_latest_spec.rb
+- spec/client_stories_popular_spec.rb
+- spec/client_stories_search_spec.rb
+- spec/client_stories_spec.rb
+- spec/client_stories_topic_spec.rb
+- spec/client_story_create_spec.rb
+- spec/client_story_delete_spec.rb
+- spec/client_story_publish_spec.rb
+- spec/client_story_save_spec.rb
+- spec/client_story_spec.rb
+- spec/client_users_spec.rb
+- spec/client_userstories_spec.rb
 - spec/pager_spec.rb
 - spec/spec_helper.rb
 - spec/storify_spec.rb
+- fixtures/vcr_cassettes/auth.yml
+- fixtures/vcr_cassettes/create.yml
+- fixtures/vcr_cassettes/delete.yml
+- fixtures/vcr_cassettes/edit_slug.yml
+- fixtures/vcr_cassettes/featured.yml
+- fixtures/vcr_cassettes/latest.yml
+- fixtures/vcr_cassettes/popular.yml
+- fixtures/vcr_cassettes/profile.yml
+- fixtures/vcr_cassettes/profile_update.yml
+- fixtures/vcr_cassettes/publish.yml
+- fixtures/vcr_cassettes/save.yml
+- fixtures/vcr_cassettes/search.yml
+- fixtures/vcr_cassettes/stories.yml
+- fixtures/vcr_cassettes/story.yml
+- fixtures/vcr_cassettes/topic.yml
+- fixtures/vcr_cassettes/users.yml
+- fixtures/vcr_cassettes/userstories.yml