storify 0.0.13 → 0.0.14

data/lib/storify.rb

@@ -50,12 +50,12 @@ module Storify
   end
 end
 
-
 require 'storify/client'
 require 'storify/pager'
 require 'storify/apierror'
 
 # base types
+require 'storify/string'
 require 'storify/features'
 require 'storify/dategroup'
 require 'storify/coverphoto'

data/lib/storify/client.rb

@@ -17,28 +17,19 @@ module Storify
       yield self if block_given?
     end
 
+
     def auth(password, options: {})
       endpoint = Storify::endpoint(version: options[:version], method: :auth)
-      data = call(endpoint, :POST, params: {password: password})
+      data = call(endpoint, :POST, params: merge_params!(params: {password: password}))
       @token = data['content']['_token']
 
       self
     end
 
-    def stories(pager: nil, options: {})
-      story_list(:stories, pager, options: options, use_auth: false)
-    end
-
-    def latest(pager: nil, options: {})
-      story_list(:latest, pager, options: options, use_auth: false)
-    end
-
-    def featured(pager: nil, options: {})
-      story_list(:featured, pager, options: options, use_auth: false)
-    end
-
-    def popular(pager: nil, options: {})
-      story_list(:popular, pager, options: options, use_auth: false)
+    %w(stories latest featured popular).each do |m|
+      define_method(m) do |pager: nil, options: {}|
+        story_list(m.to_sym, pager, options: options, use_auth: false)
+      end
     end
 
     def topic(topic, pager: nil, options: {})
@@ -68,7 +59,8 @@ module Storify
       elements = []
 
       begin
-        data = call(endpoint, :GET, paging: pager.to_hash)
+        p = merge_params!(paging: pager.to_hash)
+        data = call(endpoint, :GET, params: p)
         json = JSON.generate(data['content'])
 
         if story.nil?
@@ -96,7 +88,7 @@ module Storify
                                    method: :editslug,
                                    params: params)
 
-      data = call(endpoint, :POST, params: {slug: new_slug})
+      data = call(endpoint, :POST, params: merge_params!(params: {slug: new_slug}))
       data['content']['slug']
     end
 
@@ -109,7 +101,8 @@ module Storify
       users = []
 
       begin
-        data = call(endpoint, :GET, paging: pager.to_hash, use_auth: false)
+        p = merge_params!(paging: pager.to_hash, use_auth: false)
+        data = call(endpoint, :GET, params: p)
         content = data['content']
 
         content['users'].each do |s|
@@ -123,7 +116,7 @@ module Storify
       users
     end
 
-    def profile(username = @usernmae, options: {})
+    def profile(username = @username, options: {})
       endpoint = Storify::endpoint(version: options[:version],
                                    protocol: options[:protocol],
                                    method: :userprofile,
@@ -145,7 +138,7 @@ module Storify
                                    params: {':username' => username})
 
       json = user.to_json
-      data = call(endpoint, :POST, params: {:user => json})
+      data = call(endpoint, :POST, params: merge_params!(params: {:user => json}))
 
       true
     end
@@ -166,8 +159,8 @@ module Storify
                                    method: :create,
                                    params: {':username' => username})
 
-      data = call(endpoint, :POST, params: {:publish => publish,
-                                            :story => story.to_json})
+      p = merge_params!(params: {:publish => publish, :story => story.to_json})
+      data = call(endpoint, :POST, params: p)
 
       data['content']['slug']
     end
@@ -179,7 +172,7 @@ module Storify
                                    params: {':username' => username,
                                             ':slug' => slug})
 
-      data = call(endpoint, :POST)
+      data = call(endpoint, :POST, params: merge_params!)
 
       true
     end
@@ -208,7 +201,7 @@ module Storify
 
       # attempt to update (publish or save)
       json = story.to_json
-      data = call(endpoint, :POST, params: {:story => json})
+      data = call(endpoint, :POST, params: merge_params!(params: {:story => json}))
 
       true
     end
@@ -223,7 +216,9 @@ module Storify
       stories = []
 
       begin
-        data = call(endpoint, :GET, paging: pager.to_hash, use_auth: use_auth, params: uparams)
+        p = merge_params!(params: uparams, paging: pager.to_hash, use_auth: use_auth)
+
+        data = call(endpoint, :GET, params: p)
         content = data['content']
 
         content['stories'].each do |s|
@@ -237,28 +232,28 @@ module Storify
       stories
     end
 
-    def call(endpoint, verb, params: {}, paging: {}, opts: {}, use_auth: true)
+    def merge_params!(params: {}, paging: {}, use_auth: true)
+      params.merge!(paging)
+      params[:username] = @username
+      params[:api_key] = @api_key
+      params[:_token] = @token if (authenticated && use_auth)
+      params
+    end
+
+    def call(endpoint, verb, params: {}, opts: {})
       raw = nil
 
       begin
-        # add paging and auth query params
-        params.merge!(paging)
-        params[:username] = @username
-        params[:api_key] = @api_key
-        params[:_token] = @token if (authenticated && use_auth)
-
         case verb
         when :POST
           raw = RestClient.post endpoint, params, {:accept => :json}
         when :GET
-          raw = RestClient.get endpoint, {:params => params}
+          raw = RestClient.get endpoint, {:params => params, :accept => :json}
         end
       rescue => e
         data = JSON.parse(e.response)
         error = data['error']
 
-        puts error.inspect
-
         return Storify::error(data['code'], error['message'], error['type'], end_of_content: EOC)
       end
 

data/lib/storify/storymeta.rb

@@ -11,6 +11,7 @@ module Storify
 
     collection :quoted, :class => Storify::Quotable, :extend => Storify::QuotableRepresentable
     collection :hashtags
-    property :created_with, :class => Storify::CreatedWith, :extend => Storify::CreatedWithRepresentable
+    property :created_with, :class => lambda { |fragment, *| fragment.respond_to?(:has_key?) ? Storify::CreatedWith : String },
+                            :extend => lambda { |name, *| name.is_a?(Storify::CreatedWith) ? Storify::CreatedWithRepresentable : Storify::StringRepresentable }
   end
 end

data/lib/storify/string.rb

@@ -0,0 +1,10 @@
+require 'representable/json'
+
+module Storify
+  module StringRepresentable
+    include Representable::JSON
+
+    def to_hash(*); self; end
+    def from_hash(hsh, *args); hsh; end
+  end
+end

data/spec/client_auth_spec.rb

@@ -1,30 +1,43 @@
 require 'spec_helper'
 
 describe Storify::Client do
-  before(:each) do
-    @client = Storify::Client.new(:api_key => @api_key, :username => @username)
-  end
+  context "#auth" do
+    let(:client) {Storify::Client.new(:api_key => @api_key, :username => @username)}
+
+    it "receives a token on success" do
+      VCR.use_cassette('auth', :decode_compressed_response => true) do
+        client.auth(get_password)
+      end
 
-  context "Authentication" do
-    it "should retrieve an auth token on success" do
-      @client.auth(get_password).token.should_not be_nil
-      @client.authenticated.should be_true
+      expect(client.authenticated).to be_true
     end
 
-    it "should raise an API error on failure" do
-      expect{@client.auth('invalid_password')}.to raise_error(Storify::ApiError)
+    it "raises an API Error on failure" do
+      expect(client.authenticated).to be_false
+
+      VCR.use_cassette('auth') do
+        expect{client.auth('')}.to raise_error(Storify::ApiError)
+      end
     end
 
-    it "should accept endpoint options (version)" do
+    it "accepts endpoint options: version" do
       options = {:version => :v1}
-      @client.auth(get_password, options: options)
-      @client.authenticated.should be_true
+
+      VCR.use_cassette('auth', :decode_compressed_response => true) do
+        client.auth(get_password, options: options)
+      end
+
+      expect(client.authenticated).to be_true
     end
 
-    it "should ignore endpoint options (protocol, method)" do
+    it "ignores endpoint options: protocol, method" do
       options = {:method => :unknown, :protocol => :insecure}
-      @client.auth(get_password, options: options)
-      @client.authenticated.should be_true
+
+      VCR.use_cassette('auth', :decode_compressed_response => true) do
+        client.auth(get_password, options: options)
+      end
+
+      expect(client.authenticated).to be_true
     end
   end
 end

data/spec/client_edit_slug_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Storify::Client do
+  let(:options) { {:version => :v1, :protocol => :insecure} }
+  let(:pager) { Storify::Pager.new(page: 1, max: 1, per_page: 10) }
+  let(:slug1) { 'getting-started' }
+  let(:slug2) { 'storify-is-awesome' }
+  let(:tape) { 'edit_slug' }
+  let(:client) do
+    VCR.use_cassette('auth') do
+      Storify::Client.new(:api_key => @api_key, :username => @username).auth(get_password)
+    end
+  end
+
+  context "#edit_slug [POST /stories/:username/:story-slug/editslug]" do
+    it "responds with the new slug name" do
+      VCR.use_cassette(tape) do
+        expect(client.edit_slug(@username, slug1, slug2)).to eql slug2
+        expect(client.edit_slug(@username, slug2, slug1)).to eql slug1
+      end
+    end
+
+    it "responds with the new slug name using options: version, protocol" do
+      VCR.use_cassette(tape, :match_requests_on => vcr_ignore_protocol) do
+        expect(client.edit_slug(@username, slug1, slug2, options: options)).to eql slug2
+        expect(client.edit_slug(@username, slug2, slug1, options: options)).to eql slug1
+      end
+    end
+  end
+end

data/spec/client_profile_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Storify::Client do
+  let(:options) { {:version => :v1, :protocol => :insecure} }
+  let(:tape) { 'profile' }
+  let(:client) do
+    VCR.use_cassette('auth') do
+      Storify::Client.new(:api_key => @api_key, :username => @username).auth(get_password)
+    end
+  end
+
+  context "#profile [GET /users/:username]" do
+    it "gets a user profile" do
+      VCR.use_cassette(tape) do
+        expect(client.profile(@username).username).to eql @username
+      end
+    end
+  end
+end

data/spec/client_profile_update_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Storify::Client do
+  let(:options) { {:version => :v1, :protocol => :insecure} }
+  let(:user) { Storify::User.new.extend(Storify::UserRepresentable) }
+  let(:not_found) { 'mock_user$$$$' }
+  let(:tape) { 'profile_update' }
+  let(:rloc) { "This is a new location" }
+  let(:client) do
+    VCR.use_cassette('auth') do
+      Storify::Client.new(:api_key => @api_key, :username => @username).auth(get_password)
+    end
+  end
+
+  context "#update_profile [POST /users/:username/update]" do
+    it "raises an exception if a user is not provided" do
+      VCR.use_cassette(tape) do
+        expect{client.update_profile(nil)}.to raise_exception
+      end
+    end
+
+    it "raises an exception if the user is not found" do
+      VCR.use_cassette(tape) do
+        user.username = not_found
+        expect{client.update_profile(user)}.to raise_exception(Storify::ApiError)
+      end
+    end
+
+    it "raises an exception if the user is not found using options" do
+      VCR.use_cassette(tape, :match_requests_on => vcr_ignore_protocol) do
+        user.username = not_found
+        expect{client.update_profile(user, options: options)}.to raise_exception(Storify::ApiError)
+      end
+    end
+
+    it "raises an exception if the profile cannot be updated" do
+      VCR.use_cassette(tape) do
+        user.username = "storify"
+        expect{client.update_profile(user)}.to raise_exception(Storify::ApiError)
+      end
+    end
+
+    it "rejects profile updates for free plans" do
+      u = nil
+
+      VCR.use_cassette('profile') do
+        u = client.profile(@username)
+        u.location = rloc
+      end
+
+      VCR.use_cassette(tape) do
+        expect(u.paid_plan).to eql "free"
+        expect{client.update_profile(u)}.to raise_exception(Storify::ApiError)
+      end
+    end
+  end
+end

data/spec/client_spec.rb

@@ -1,256 +1,43 @@
 require 'spec_helper'
 
 describe Storify::Client do
-  before(:all) do
-    @client = Storify::Client.new(:api_key => @api_key, :username => @username)
-    @client.auth(get_password)
-  end
+  let(:key) { 'k' }
+  let(:usr) { 'u' }
+  let(:tok) { 't' }
 
   context ".new" do
-    it "should accept a hash of credentials (api_key, username, token)" do
-      clients = [Storify::Client.new(:api_key => 'k', :username => 'u', :token => 't'),
-                 Storify::Client.new('api_key' => 'k', 'username' => 'u', 'token' => 't')]
+    it "accepts a hash of credentials as symbols" do
+      client = Storify::Client.new(:api_key => key, :username => usr, :token => tok)
+      expect(client.api_key).to eql key
+      expect(client.username).to eql usr
+      expect(client.token).to eql tok
+    end
 
-      clients.each do |c|
-        c.api_key.should == 'k'
-        c.username.should == 'u'
-        c.token.should == 't'
-      end
+    it "accepts a hash of credentials as strings" do
+      client = Storify::Client.new('api_key' => key, 'username' => usr, 'token' => tok)
+      expect(client.api_key).to eql key
+      expect(client.username).to eql usr
+      expect(client.token).to eql tok
     end
 
-    it "should accept a configuration block of credentials" do
+    it "accepts a block of credentials" do
       client = Storify::Client.new do |config|
-        config.api_key = 'YOUR API KEY'
-        config.username = 'YOUR USERNAME'
-        config.token = 'YOUR AUTH TOKEN'
+        config.api_key = key
+        config.username = usr
+        config.token = tok
       end
 
-      client.api_key.should == 'YOUR API KEY'
+      expect(client.api_key).to eql key
+      expect(client.username).to eql usr
+      expect(client.token).to eql tok
     end
 
-    it "should raise an exception for unknown credentials" do
+    it "raises an exception for unknown hash credentials" do
       expect {Storify::Client.new(:unknown => 'value')}.to raise_exception
-      expect {Storify::Client.new {|config| config.unknown = ''}}.to raise_exception
-    end
-  end
-
-  context "GET /stories/:username" do
-    it "should get all stories for a specific user" do
-      @client.userstories(@username).length.should >= 2
-    end
-
-    it "should accept endpoint options (version, protocol)" do
-      options = {:version => :v1, :protocol => :insecure}
-      @client.userstories(@username, options: options).length.should >= 2
-    end
-
-    it "should accept paging options (Pager)" do
-      pager = Storify::Pager.new(page: 1, max: 1, per_page: 10)
-      stories = @client.userstories('joshuabaer', pager: pager)
-      stories.length.should == 10
-    end
-  end
-
-  context "GET /stories/:username/:slug" do
-    before(:all) do
-      puts "Enter a Story-Slug for your Account:"
-      @slug = STDIN.gets.chomp
-    end
-
-    it "should get a specific story for a user (all pages)" do
-      @client.story(@slug).elements.length.should == 3
-    end
-
-    it "should accept endpoint options (version, protocol)" do
-      options = {:version => :v1, :protocol => :insecure}
-      @client.story(@slug, options: options).elements.length.should == 3
-    end
-
-    it "should accept paging options (Page)" do
-      pager = Storify::Pager.new(page: 2, max: 3)
-      story = @client.story('austin-startup-digest-for-december-9-2014', 'joshuabaer', pager: pager)
-      story = story.to_s
-
-      ['408651138632667136', '409182832234213376'].each {|s| story.include?(s).should be_true }
-     end
-  end
-
-  context "POST /stories/:username/:story-slug/editslug" do
-    before(:all) do
-      puts "Enter a Story-Slug for your Account:"
-      @slug1 = STDIN.gets.chomp
-
-      puts "Enter a New Unique Story-Slug for your Account"
-      @slug2 = STDIN.gets.chomp
-    end
-
-    it "should respond with the new slug name (on a successful change)" do
-      @client.edit_slug(@username, @slug1, @slug2).should == @slug2
-      @client.edit_slug(@username, @slug2, @slug1).should == @slug1
-    end
-
-    it "should accept endpoint options (version, protocol)" do
-      opts = {:version => :v1, :protocol => :insecure}
-      @client.edit_slug(@username, @slug1, @slug2, options: opts).should == @slug2
-      @client.edit_slug(@username, @slug2, @slug1, options: opts).should == @slug1
-    end
-  end
-
-  context "GET /users/:username" do
-    it "should get a specific user's profile" do
-      @client.profile(@username).username.should == @username
-    end
-  end
-
-  context "POST /stories/:username/:slug/publish" do
-    it "should raise an exception if a story is not provided" do
-      expect{@client.publish(nil)}.to raise_exception
-    end
-
-    it "should raise an exception if the story is not found" do
-      story = Storify::Story.new.extend(Storify::StoryRepresentable)
-      author = Storify::User.new.extend(Storify::UserRepresentable)
-      author.username = 'rtejpar'
-      story.author = author
-      story.slug = 'does-not-exist-story'
-
-      expect{@client.publish(story)}.to raise_exception(Storify::ApiError)
-    end
-
-    it "should raise an exception if you do not have permission to publish" do
-      story = Storify::Story.new.extend(Storify::StoryRepresentable)
-      author = Storify::User.new.extend(Storify::UserRepresentable)
-      author.username = 'storify'
-      story.author = author
-      story.slug = 'storify-acquired-by-livefyre'
-
-      expect{@client.publish(story)}.to raise_exception(Storify::ApiError)
-    end
-
-    it "should publish an existing story" do
-      story = @client.story('test-story', @username)
-      @client.publish(story).should == true
-    end
-
-    it "should accept endpoint options" do
-      options = {:version => :v1, :protocol => :insecure}
-      story = @client.story('test-story', @username)
-      @client.publish(story, options: options).should == true
     end
 
-    it "should allow changes to the story during a publish" do
-      story = @client.story('no-embeds', @username)
-      new_desc = "New Description #{Random.new(Random.new_seed).to_s}"
-
-      story.description = new_desc
-      story.description.should == new_desc
-      @client.publish(story).should == true
-
-      revised = @client.story('no-embeds', @username)
-      revised.description.should == new_desc
-    end
-  end
-
-  context "POST /users/:username/update" do
-    it "should raise an exception if a user is not provided" do
-      expect{@client.update_profile(nil)}.to raise_exception
-    end
-
-    it "should raise an exception if the user cannot be found" do
-      user = Storify::User.new.extend(Storify::UserRepresentable)
-      user.username = "rtejpar$$$$"
-      expect{@client.update_profile(user)}.to raise_exception(Storify::ApiError)
-    end
-
-    it "should raise an exception if the profile cannot be updated" do
-      user = Storify::User.new.extend(Storify::UserRepresentable)
-      user.username = "storify"
-      expect{@client.update_profile(user)}.to raise_exception(Storify::ApiError)
-    end
-
-    it "should accept/reject updates to profile information based on plan status" do
-      user = @client.profile(@username)
-      user.location = "Loc #{Random.new(Random.new_seed).to_s}"
-
-      if user.paid_plan == "free"
-        expect{@client.update_profile(user)}.to raise_exception(Storify::ApiError)
-      else
-        @client.update_profile(user).should == true
-      end
-    end
-
-    it "should support endpoint options" do
-      options = {:version => :v1, :protocol => :insecure}
-      user = Storify::User.new.extend(Storify::UserRepresentable)
-      user.username = "rtejpar$$$$"
-      expect{@client.update_profile(user, options: options)}.to raise_exception(Storify::ApiError)
-    end
-  end
-
-  context "POST /stories/:username/:slug/save" do
-    it "should save an existing story" do
-      story = @client.story('no-embeds', @username)
-      element = Storify::Element.new.extend(Storify::ElementRepresentable)
-      element.data = Storify::StoryData.new.extend(Storify::StoryDataRepresentable)
-      element.data.text = "Added new text item"
-
-      # add new element via permalink to end of story
-      story.elements << element
-
-      @client.save(story).should == true
-
-      # publish changes to make them retrievable
-      @client.publish(story).should == true
-
-      # updated
-      revised = @client.story('no-embeds', @username)
-      revised.elements.length.should == 1
-
-      # test removal
-      revised.elements = []
-      @client.save(revised).should == true
-      @client.publish(revised).should == true
-    end
-  end
-
-  context "POST /stories/:username/create" do
-    it "should create a story with multiple elements" do
-      story = Storify::Story.new.extend(Storify::StoryRepresentable)
-      story.title = "Another Story"
-
-      story.elements = []
-      story.elements << Storify::Element.new.extend(Storify::ElementRepresentable)
-      story.elements << Storify::Element.new.extend(Storify::ElementRepresentable)
-      story.elements << Storify::Element.new.extend(Storify::ElementRepresentable)
-
-      # add text data item
-      item = story.elements[0]
-      item.data = Storify::StoryData.new.extend(Storify::StoryDataRepresentable)
-      item.data.text = "Start of the story..."
-
-      # add twitter link
-      item = story.elements[1]
-      item.permalink = "http://twitter.com/fmquaglia/status/409875377482264577"
-
-      # twitter link with image
-      item = story.elements[2]
-      item.permalink = "http://twitter.com/NicholleJ/status/407924506380861441"
-
-      slug = @client.create(story, true)
-      slug.should_not eql ""
-    end
-  end
-
-  context "POST /stories/:username/:slug/delete" do
-    it "should delete the specified story" do
-      @client.delete('another-story', @username).should == true
-    end
-  end
-
-  context "Serialization" do
-    it "should allow a story to be serialized as text" do
-      story = @client.story('austin-startup-digest-for-december-9-2014', 'joshuabaer')
-      story.should_not eql ""
+    it "raises an exception for unknown block credentials" do
+      expect {Storify::Client.new {|config| config.unknown = ''}}.to raise_exception
     end
   end
 end