ruby-stackoverflow 0.0.2

data/spec/helper.rb

@@ -0,0 +1,45 @@
+VCR.configure do |c|
+  c.cassette_library_dir = 'spec/fixtures/vcr_cassettes'
+  c.allow_http_connections_when_no_cassette = true
+  c.hook_into :webmock # or :fakeweb
+end
+
+def configure_stackoverflow
+  RubyStackoverflow.configure do|config|
+    config.client_key = 'pfllsDjWHeLGWoWIT5rRdA(('
+    config.access_token = 'L0J88cciBPHiGtIKCul6Gg))'
+  end
+end
+
+def stub_get(url, params={})
+  stub_request(:get, stackoverflow_url(url, params))
+end
+
+def fixture_path
+  File.expand_path("../fixtures", __FILE__)
+end
+
+def fixture(file)
+  File.new(fixture_path + '/' + file)
+end
+
+def json_response(file)
+  {
+    :body => fixture(file),
+    :headers => {
+      :content_type => 'application/json; charset=utf-8'
+    }
+  }
+end
+
+def stackoverflow_url(url, params)
+  url = basic_stackoverflow_url + url + '?key=dsadsadasd999&site=stackoverflow'
+  params.each do|k,v|
+    url.concat("&#{k}=#{v}")
+  end
+  url
+end
+
+def basic_stackoverflow_url
+  'https://api.stackexchange.com/2.1/'
+end

data/spec/ruby-stackoverflow/badges_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+module RubyStackoverflow
+  describe Client::BadgesHelper do
+    before(:each) do
+      configure_stackoverflow
+      @user_basic_url= 'badges/'
+    end
+
+    it 'should find badges' do
+      VCR.use_cassette('badges') do
+        response = RubyStackoverflow.badges({min: 'gold', max: 'bronze', sort: 'rank'})
+        response.data.is_a?(Array).should be_true
+        expect(response.data.count).to eq(30)
+        expect(response.data.first.name).to eq('cryptography')
+      end
+    end
+
+    it 'should find badges by ids' do
+      VCR.use_cassette('badges_by_ids') do
+        response = RubyStackoverflow.badges_by_ids([263, 264], {min: 'gold', max: 'bronze', sort: 'rank'})
+        response.data.is_a?(Array).should be_true
+        expect(response.data.count).to eq(2)
+        expect(response.data.first.name).to eq('cryptography')
+      end
+    end
+
+    it 'should find badges by name' do
+      VCR.use_cassette('badges_by_name') do
+        response = RubyStackoverflow.badges_by_name({inname: 'teacher',min: 'gold', max: 'bronze', sort: 'rank'})
+        response.data.is_a?(Array).should be_true
+        expect(response.data.count).to eq(1)
+        expect(response.data.first.name).to eq('Teacher')
+      end
+    end
+
+    it 'should find recently added badges' do
+      VCR.use_cassette('badges_by_recipients') do
+        response = RubyStackoverflow.badges_between_dates({page: 1, pagesize: 10, fromdate: '2013-08-01', todate: '2013-10-22'})
+        response.data.is_a?(Array).should be_true
+        expect(response.data.count).to eq(10)
+        expect(response.data.first.name).to eq('Nice Answer')
+      end
+    end
+
+    it 'should find recently added badges by ids' do
+      VCR.use_cassette('badges_by_recipients_by_ids') do
+        response = RubyStackoverflow.badges_between_dates_by_ids([146, 20],{page: 1, pagesize: 10, fromdate: '2013-08-01', todate: '2013-10-22'})
+        response.data.is_a?(Array).should be_true
+        expect(response.data.count).to eq(10)
+        expect(response.data.first.name).to eq('Nice Question')
+      end
+    end
+
+    it 'should find badges by tags' do
+      VCR.use_cassette('badges_by_tags') do
+        response = RubyStackoverflow.badges_by_tags({inname: 'ruby-on-rails',min: 'gold', max: 'bronze', sort: 'rank'})
+        response.data.is_a?(Array).should be_true
+        expect(response.data.count).to eq(7)
+        expect(response.data.first.name).to eq('ruby-on-rails')
+      end
+    end
+  end
+end

data/spec/ruby-stackoverflow/comments_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+module RubyStackoverflow
+  describe Client::CommentsHelper do
+    before(:each) do
+      configure_stackoverflow
+      @comments_basic_url= 'users/'
+      WebMock.allow_net_connect!
+    end
+
+    it 'should fetch comments' do
+      VCR.use_cassette('comments') do
+        response = RubyStackoverflow.comments({min: 1, max: 10, sort: 'votes'})
+        response.data.is_a?(Array).should be_true
+        expect(response.data.count).to eq(30)
+        expect(response.data.first.edited).to eq(false)
+        expect(response.data.first.score).to eq(10)
+      end
+    end
+
+    it 'should fetch comments by ids' do
+      VCR.use_cassette('comments_by_ids') do
+        response = RubyStackoverflow.comments_by_ids(['129085', '131326'])
+        response.data.is_a?(Array).should be_true
+        expect(response.data.count).to eq(2)
+        expect(response.data.first.edited).to eq(false)
+        expect(response.data.first.score).to eq(10)
+      end
+    end
+
+  end
+end

data/spec/ruby-stackoverflow/question_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+module RubyStackoverflow
+  describe Client::QuestionHelper do
+    before(:each) do
+      configure_stackoverflow
+      @question_basic_url = 'questions/'
+    end
+
+    it 'should get questions' do
+      VCR.use_cassette('questions') do
+        response = RubyStackoverflow.questions
+        response.data.is_a?(Array).should be_true
+        response.data.last.respond_to?(:answer_count).should be_true
+      end
+    end
+
+    it 'should get questions by id' do
+      VCR.use_cassette('questions_by_ids') do
+        response = RubyStackoverflow.questions_by_ids(['19294359'])
+        response.data.is_a?(Array).should be_true
+        response.data.last.respond_to?(:answer_count).should be_true
+      end
+    end
+
+    it 'should get answers of questions' do
+      VCR.use_cassette('questions_answers') do
+        response = RubyStackoverflow.answers_of_questions(['16067043','19401289'])
+        response.data.is_a?(Array).should be_true
+        expect(response.data.last.answers.count).to eq(1)
+        expect(response.data.first.answers.last.answer_id).to eq(19401432)
+      end
+    end
+
+    it 'should get comments of questions' do
+      VCR.use_cassette('questions_comments') do
+        response = RubyStackoverflow.comments_of_questions(['13804832'])
+        data = response.data.last
+        response.data.is_a?(Array).should be_true
+        data.respond_to?(:comments).should be_true
+        expect(data.comments.first.owner[:user_id]).to eq(87189)
+      end
+    end
+
+    it 'should get linked questions' do
+      VCR.use_cassette('linked_questions') do
+        response = RubyStackoverflow.linked_questions(['13804832'])
+        response.data.is_a?(Array).should be_true
+      end
+    end
+
+    it 'should get related questions' do
+      VCR.use_cassette('related_questions') do
+        response = RubyStackoverflow.related_questions(['13804832'])
+        response.data.is_a?(Array).should be_true
+      end
+    end
+
+    it 'should get timeline questions' do
+      VCR.use_cassette('timeline_questions') do
+        response = RubyStackoverflow.timeline_of_questions(['13804832','16067043'])
+        data = response.data.first
+        response.data.is_a?(Array).should be_true
+        data.posts.first.respond_to?(:timeline_type).should be_true
+        expect(data.posts.first.timeline_type).to eq('comment')
+      end
+    end
+
+    it 'should get featured questions' do
+      VCR.use_cassette('featured_questions') do
+        response = RubyStackoverflow.featured_questions({page: 1,pagesize: 1})
+        response.data.is_a?(Array).should be_true
+      end
+    end
+
+    it 'should get unanswered questions' do
+      VCR.use_cassette('unanswered_questions') do
+        response = RubyStackoverflow.unanswered_questions({tagged:'rails',pagesize: 1, page: 1})
+        response.data.is_a?(Array).should be_true
+      end
+    end
+
+    it 'should get noanswered questions' do
+      VCR.use_cassette('noanswered_questions') do
+        response = RubyStackoverflow.noanswered_questions({tagged:'rails', pagesize: 1, page: 1})
+        response.data.is_a?(Array).should be_true
+      end
+    end
+  end
+end

data/spec/ruby-stackoverflow/user_spec.rb

@@ -0,0 +1,289 @@
+require 'spec_helper'
+module RubyStackoverflow
+  describe Client::UserHelper do
+    before(:each) do
+      configure_stackoverflow
+      @user_basic_url= 'users/'
+    end
+
+    it 'should find users' do
+      VCR.use_cassette('users') do
+        response = RubyStackoverflow.users({inname: 'raysrashmi', sort: 'reputation'})
+        response.data.is_a?(Array).should be_true
+        expect(response.data.first.display_name).to eq('raysrashmi')
+        expect(response.data.first.creation_date).to eq('2012-04-28 18:05:37 UTC')
+      end
+    end
+
+    it 'should get user by id' do
+      VCR.use_cassette('users_by_ids') do
+        stub_get(@user_basic_url+'1363236').to_return(json_response('users.json'))
+        response = RubyStackoverflow.users_by_ids(['1363236'])
+        response.data.is_a?(Array).should be_true
+        response.data.last.respond_to?(:display_name).should be_true
+        expect(response.data.first.display_name).to eq('raysrashmi')
+      end
+    end
+
+    it 'should get error' do
+      VCR.use_cassette('error') do
+        response = RubyStackoverflow.users_by_ids(['1363236&&'])
+        response.data.should be_nil
+        response.error.should_not be_nil
+        expect(response.error.error_code).to eq(404)
+        expect(response.error.error_message).to eq("no method found with this name")
+      end
+    end
+
+    it 'should get user answers' do
+      VCR.use_cassette('users_answers') do
+        response = RubyStackoverflow.users_with_answers(['1363236'],{min: '2013-10-01', max: '2013-10-24'})
+        response.data.is_a?(Array).should be_true
+        response.data.last.respond_to?(:display_name).should be_true
+        expect(response.data.first.display_name).to eq('raysrashmi')
+        expect(response.data.first.answers.count).to eq(13)
+        expect(response.data.first.answers.last.answer_id).to eq(19449714)
+        expect(response.data.first.answers.last.last_activity_date).to eq('2013-10-18 15:57:17 UTC')
+      end
+    end
+
+    it 'should get user badges' do
+      VCR.use_cassette('users_badges') do
+        response = RubyStackoverflow.users_with_badges(['1363236'],{order: 'asc'})
+        response.data.is_a?(Array).should be_true
+        response.data.last.respond_to?(:display_name).should be_true
+        expect(response.data.first.display_name).to eq('raysrashmi')
+        expect(response.data.first.badges.count).to eq(5)
+        expect(response.data.first.badges.first.name).to eq('Teacher')
+      end
+    end
+
+    it 'should get user comments' do
+      VCR.use_cassette('users_comments') do
+        response = RubyStackoverflow.users_with_comments(['1363236'],{sort: 'votes'})
+        response.data.is_a?(Array).should be_true
+        response.data.last.respond_to?(:display_name).should be_true
+        expect(response.data.count).to eq(1)
+        expect(response.data.first.display_name).to eq('raysrashmi')
+        expect(response.data.first.comments.count).to eq(17)
+        expect(response.data.first.comments.first.score).to eq(1)
+        expect(response.data.first.comments.first.comment_id).to eq(28886246)
+      end
+    end
+
+    it 'should get user replied comments' do
+      VCR.use_cassette('users_replied_comments') do
+        response = RubyStackoverflow.users_with_replied_comments(['707894','1004415'], '1300151')
+        response.data.is_a?(Array).should be_true
+        response.data.last.respond_to?(:display_name).should be_true
+        expect(response.data.first.display_name).to eq('felipeclopes')
+        expect(response.data.first.comments.count).to eq(1)
+        expect(response.data.first.comments.first.score).to eq(0)
+        expect(response.data.first.comments.first.comment_id).to eq(28452392)
+      end
+    end
+
+    it 'should get users favorites questions' do
+      VCR.use_cassette('users_favorites_questions') do
+        response = RubyStackoverflow.users_with_favorites_questions(['707894','1004415'])
+        response.data.is_a?(Array).should be_true
+        response.data.last.respond_to?(:display_name).should be_true
+        expect(response.data.first.display_name).to eq('Joel Grannas')
+        expect(response.data.first.questions.count).to eq(1)
+        expect(response.data.first.questions.last.view_count).to eq(151)
+      end
+    end
+    it 'should get questions where users are mentioned' do
+      VCR.use_cassette('users_mentioned_questions') do
+        response = RubyStackoverflow.users_with_mentioned_comments(['707894','1004415'])
+        response.data.is_a?(Array).should be_true
+        response.data.last.respond_to?(:display_name).should be_true
+        expect(response.data.first.display_name).to eq('Carlos Drew')
+        expect(response.data.first.comments.count).to eq(1)
+        expect(response.data.first.comments.last.score).to eq(0)
+      end
+    end
+
+    it 'should get users notifications' do
+      VCR.use_cassette('users_notifications') do
+        response = RubyStackoverflow.users_notifications('1363236')
+        response.data.is_a?(Array).should be_true
+        response.data.last.respond_to?(:notification_type).should be_true
+        expect(response.data.first.site[:site_type]).to eq('main_site')
+        expect(response.data.count).to eq(16)
+      end
+    end
+    it 'should get users unread notifications' do
+      VCR.use_cassette('users_unread_notifications') do
+        response = RubyStackoverflow.users_unread_notifications('1363236')
+        response.data.is_a?(Array).should be_true
+        response.data.last.respond_to?(:notification_type).should be_false
+      end
+    end
+
+    it 'should get users questions' do
+      VCR.use_cassette('users_questions') do
+        response = RubyStackoverflow.users_questions(['1363236'])
+        response.data.is_a?(Array).should be_true
+        response.data.last.respond_to?(:display_name).should be_true
+        expect(response.data.first.display_name).to eq('raysrashmi')
+        expect(response.data.first.questions.count).to eq(3)
+        expect(response.data.first.questions.last.view_count).to eq(65)
+      end
+    end
+
+    it 'should get users featured questions' do
+      VCR.use_cassette('users_featured_questions') do
+        response = RubyStackoverflow.users_featured_questions(['1363236'])
+        response.data.is_a?(Array).should be_true
+      end
+    end
+
+    it 'should get users no answer questions' do
+      VCR.use_cassette('users_noanswerquestions') do
+        response = RubyStackoverflow.users_noanswers_questions(['1363236'])
+        response.data.is_a?(Array).should be_true
+        response.data.should_not be_empty
+      end
+    end
+
+    it 'should get users unanswered questions' do
+      VCR.use_cassette('users_unanswered_questions') do
+        response = RubyStackoverflow.users_unanswered_questions(['707894'])
+        response.data.is_a?(Array).should be_true
+        response.data.last.respond_to?(:display_name).should be_true
+        expect(response.data.first.display_name).to eq('felipeclopes')
+        expect(response.data.first.questions.count).to eq(6)
+        expect(response.data.first.questions.last.view_count).to eq(1344)
+      end
+    end
+
+    it 'should get users unaccepted questions' do
+      VCR.use_cassette('users_unaccepted_questions') do
+        response = RubyStackoverflow.users_unaccepted_questions(['1363236'])
+        response.data.is_a?(Array).should be_true
+        response.data.last.respond_to?(:display_name).should be_true
+        expect(response.data.first.display_name).to eq('raysrashmi')
+        expect(response.data.first.questions.count).to eq(2)
+        expect(response.data.first.questions.last.view_count).to eq(65)
+      end
+    end
+
+    it 'should get users reputation' do
+      VCR.use_cassette('users_reputation_questions') do
+        response = RubyStackoverflow.users_reputations(['1363236'])
+        response.data.is_a?(Array).should be_true
+        expect(response.data.count).to eq(1)
+        expect(response.data.first.reputations.count).to eq(12)
+        expect(response.data.first.reputations.last.vote_type).to eq('down_votes')
+        expect(response.data.first.reputations.last.post_type).to eq('question')
+      end
+    end
+
+    it 'should get users suggested edits' do
+      VCR.use_cassette('users_suggested_edits') do
+        response = RubyStackoverflow.users_suggested_edits(['707894'])
+        response.data.is_a?(Array).should be_true
+        expect(response.data.count).to eq(1)
+        response.data.last.respond_to?(:display_name).should be_true
+        expect(response.data.first.display_name).to eq('felipeclopes')
+        expect(response.data.first.suggested_edits.count).to eq(8)
+        expect(response.data.first.suggested_edits.last.post_type).to eq('answer')
+      end
+    end
+
+    it 'should get users tags' do
+      VCR.use_cassette('users_tags') do
+        response = RubyStackoverflow.users_tags(['707894'],{min: 1, max: 10, sort: 'popular' })
+        response.data.is_a?(Array).should be_true
+        expect(response.data.count).to eq(1)
+        response.data.last.respond_to?(:user_id).should be_true
+        expect(response.data.first.tags.count).to eq(30)
+        expect(response.data.first.tags.last.name).to eq('angularjs-directive')
+      end
+    end
+
+    it 'should get user top answers for specific tags' do
+      VCR.use_cassette('user_top_answers_with_given_tags') do
+        response = RubyStackoverflow.users_top_answers_with_given_tags('707894',['ruby', 'rails'])
+        response.data.is_a?(Array).should be_true
+        expect(response.data.count).to eq(1)
+        response.data.last.respond_to?(:user_id).should be_true
+        expect(response.data.first.answers.count).to eq(9)
+        expect(response.data.first.answers.last.score).to eq(0)
+      end
+    end
+
+    it 'should get user top questions for specific tags' do
+      VCR.use_cassette('user_top_questions_with_given_tags') do
+        response = RubyStackoverflow.users_top_questions_with_given_tags('707894',['ruby', 'rails'])
+        response.data.is_a?(Array).should be_true
+        expect(response.data.count).to eq(1)
+        response.data.last.respond_to?(:user_id).should be_true
+        expect(response.data.first.questions.count).to eq(3)
+        expect(response.data.first.questions.last.score).to eq(-2)
+      end
+    end
+
+    it 'should Ggt the top tags (by score) a user has posted answers in' do
+      VCR.use_cassette('user_top_tags_by_answers') do
+        response = RubyStackoverflow.user_top_tags_by_answers('707894')
+        data = response.data
+
+        data.is_a?(Array).should be_true
+        expect(data.count).to eq(1)
+
+        data.last.respond_to?(:user_id).should be_true
+
+        expect(data.first.tags.count).to eq(30)
+        expect(data.first.tags.last.tag_name).to eq('asp.net-mvc')
+      end
+    end
+
+    it 'should Ggt the top tags (by score) a user has posted questions' do
+      VCR.use_cassette('user_top_tags_by_questions') do
+        response = RubyStackoverflow.user_top_tags_by_questions('707894')
+        data = response.data
+
+        data.is_a?(Array).should be_true
+        expect(data.count).to eq(1)
+
+        data.last.respond_to?(:user_id).should be_true
+
+        expect(data.first.tags.count).to eq(12)
+        expect(data.first.tags.last.tag_name).to eq('timezone')
+      end
+    end
+
+    it 'should get user timeline' do
+      VCR.use_cassette('user_timeline') do
+        response = RubyStackoverflow.users_timeline(['1363236'],{fromdate: '2013-10-17', todate: '2013-10-20'})
+        data = response.data
+
+        data.is_a?(Array).should be_true
+        expect(data.count).to eq(1)
+
+        data.last.respond_to?(:user_id).should be_true
+
+        expect(data.first.posts.count).to eq(16)
+        expect(data.first.posts.last.timeline_type).to eq('revision')
+      end
+    end
+
+    it 'should get user write permission' do
+      VCR.use_cassette('user_write_permissions') do
+        response = RubyStackoverflow.user_write_permissions('1363236')
+        data = response.data
+
+        data.is_a?(Array).should be_true
+        expect(data.count).to eq(1)
+
+        data.last.respond_to?(:user_id).should be_true
+
+        expect(data.first.permissions.count).to eq(3)
+        expect(data.first.permissions.last.can_edit).to eq(true)
+      end
+    end
+  end
+end
+