social_auth 0.0.9

data/spec/models/facebook_service_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+module SocialAuth
+
+  describe FacebookService do
+    before :each do
+      @user = User.create(email: "email@address.com")
+      allow_any_instance_of(FacebookService).to receive(:redis_instance).and_return(Redis.new)
+      allow_any_instance_of(FacebookService).to receive(:append_to_associated_services).and_return(true)
+    end
+
+    describe "social login methods" do
+      it "receives init_with on authenticate" do
+        expect(FacebookService).to receive(:init_with)
+        SocialAuth.authenticate("facebook", {access_token: "access_token"})
+      end
+
+      it "receives connect_with on connect" do
+        expect(FacebookService).to receive(:connect_with)
+        SocialAuth.connect(@user, "facebook", {access_token: "access_token"})
+      end
+    end
+
+    describe "exception raising" do
+      it "invalid token raises InvalidToken error" do
+        VCR.use_cassette('facebook_service/invalid_request') do
+          expect{
+            FacebookService.init_with({access_token: "343421"})
+            }.to raise_error InvalidToken
+        end
+      end
+    end
+
+    describe "self.init_with" do
+      before :each do
+        #create an override method on user which gets called whenever
+        #we want a user created you do the rest!
+        User.class_eval do
+          has_many :services, inverse_of: :user, class_name: SocialAuth::Service
+          def self.create_with_facebook_request(request)
+            new
+          end
+        end
+      end
+
+      it "creates service if doesn't exist" do
+        VCR.use_cassette('facebook_service/valid_request') do
+          expect{
+            FacebookService.init_with(fb_access_token)
+          }.to change(FacebookService, :count).by(1)
+        end
+      end
+
+      it "User receives override method" do
+        expect(User).to receive(:create_with_facebook_request).once
+        VCR.use_cassette('facebook_service/valid_request') do
+          FacebookService.init_with(fb_access_token)
+        end
+      end
+    end
+
+    describe "create_connection" do
+      it "returns valid connection" do
+        VCR.use_cassette('facebook_service/valid_request') do
+          expect{
+            FacebookService.create_connection(fb_access_token)
+          }.to_not raise_error
+        end
+      end
+
+      it "raises invalid token" do
+        VCR.use_cassette('facebook_service/invalid_token') do
+          expect{
+            FacebookService.create_connection({access_token: "invalid_token"})
+          }.to raise_error InvalidToken
+        end
+      end
+
+    end
+
+    describe "self.connect_with" do
+      it "creates service if doesn't exist" do
+        VCR.use_cassette('facebook_service/valid_request') do
+          expect{
+            FacebookService.connect_with(@user, fb_access_token)
+          }.to change(FacebookService, :count).by(1)
+        end
+      end
+    end
+
+    describe "friend_ids" do
+      before :each do
+        @service = FacebookService.create(access_token: fb_access_token, remote_id: "10204796229055532", user: @user, method: "Authenticated")
+      end
+
+      it "returns friend_ids" do
+        VCR.use_cassette("facebook_service/valid_friends_request") do
+          expect{
+            expect(@service.friend_ids).to_not be_empty
+          }.to_not raise_error
+        end
+      end
+
+      it "if user has no friends returns empty array" do
+        allow_any_instance_of(FbGraph2::Edge::Friends).to receive(:friends).and_return([])
+        VCR.use_cassette("facebook_service/valid_friends_request") do
+          expect{
+            expect(@service.friend_ids).to be_empty
+          }.to_not raise_error
+        end
+      end
+
+      it "invalid_token returns empty array and hits disconnect callback" do
+        service = FacebookService.create(access_token: {access_token: "test"}, remote_id: "10204796229055532", user: @user, method: "Authenticated")
+
+        expect_any_instance_of(FacebookService).to receive(:disconnect).once
+        VCR.use_cassette("facebook_service/invalid_friends_request") do
+          expect{
+            expect(@service.friend_ids).to be_empty
+          }.to_not raise_error
+        end
+      end
+
+    end
+
+  end
+end

data/spec/models/google_plus_service_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+module SocialAuth
+
+  describe GooglePlusService do
+    before :each do
+      @user = User.create(email: "email@address.com")
+      allow_any_instance_of(GooglePlusService).to receive(:redis_instance).and_return(Redis.new)
+      allow_any_instance_of(GooglePlusService).to receive(:append_to_associated_services).and_return(true)
+      SocialAuth.google_client_id = "1053743633063-aaearku9rl008rc8vq7muvreifc4jbo8.apps.googleusercontent.com"
+      SocialAuth.google_client_secret = "rK6Fkmo6qpiiy0_SnWJDOlgv"
+      SocialAuth.google_redirect_uri = "https://developers.google.com/oauthplayground"
+      SocialAuth.google_api_key = "AIzaSyAKMHRoLKyRo5rivF8hq_Ic3SmvphBYIBk"
+    end
+
+    describe "social login methods" do
+      it "receives init_with on authenticate" do
+        expect(GooglePlusService).to receive(:init_with)
+        SocialAuth.authenticate("google_plus", {access_token: "access_token"})
+      end
+
+      it "receives connect_with on connect" do
+        expect(GooglePlusService).to receive(:connect_with)
+        SocialAuth.connect(@user, "google_plus", {access_token: "access_token"})
+      end
+    end
+
+    describe "self.init_with" do
+      before :each do
+        #create an override method on user which gets called whenever
+        #we want a user created you do the rest!
+        User.class_eval do
+          has_many :services, inverse_of: :user, class_name: SocialAuth::Service
+          def self.create_with_google_plus_request(request)
+            new
+          end
+        end
+      end
+
+      it "creates service if doesn't exist" do
+        VCR.use_cassette('google_plus_service/valid_request') do
+          expect{
+            GooglePlusService.init_with(google_plus_access_token)
+          }.to change(GooglePlusService, :count).by(1)
+        end
+      end
+
+      it "User receives override method" do
+        expect(User).to receive(:create_with_google_plus_request).once
+        VCR.use_cassette('google_plus_service/valid_request') do
+          GooglePlusService.init_with(google_plus_access_token)
+        end
+      end
+    end
+
+    describe "self.connect_with" do
+      it "creates service if doesn't exist" do
+        VCR.use_cassette('google_plus_service/valid_request') do
+          expect{
+            GooglePlusService.connect_with(@user, google_plus_access_token)
+          }.to change(GooglePlusService, :count).by(1)
+        end
+      end
+
+      it "invalid_token raises InvalidToken exception" do
+        VCR.use_cassette('google_plus_service/invalid_token') do
+          expect{
+            GooglePlusService.connect_with(@user, {auth_token: "wrong"})
+          }.to raise_error InvalidToken
+        end
+      end
+    end
+
+    describe "create_connection" do
+      it "fetches token correctly" do
+        VCR.use_cassette("google_plus_service/valid_authorization") do
+          response = GooglePlusService.fetch_access_token({auth_token: google_plus_auth_token})
+          expect(response[:refresh_token]).to be_present
+        end
+      end
+
+      it "fetches token correctly" do
+        VCR.use_cassette("google_plus_service/invalid_authorization") do
+          expect{
+            GooglePlusService.fetch_access_token({auth_token: "bad-token"})
+          }.to raise_error InvalidToken
+        end
+      end
+
+      it "returns valid connection" do
+        VCR.use_cassette('google_plus_service/valid_request') do
+          expect{
+            GooglePlusService.create_connection(google_plus_access_token)
+          }.to_not raise_error
+        end
+      end
+    end
+
+    describe "friend_ids" do
+      before :each do
+        @service = GooglePlusService.create(access_token: {refresh_token:  google_plus_access_token[:refresh_token]}, remote_id: "410739240", user: @user, method: "Authenticated")
+      end
+
+      it "returns friend_ids" do
+        VCR.use_cassette("google_plus_service/valid_friends_request") do
+          expect{
+            expect(@service.friend_ids).to_not be_empty
+          }.to_not raise_error
+        end
+      end
+
+      it "doesn't raise error if user has no friends" do
+        expect_any_instance_of(GooglePlusService).to receive(:google_items).and_return(nil)
+        VCR.use_cassette("google_plus_service/valid_friends_request") do
+          expect{
+            expect(@service.friend_ids).to be_empty
+          }.to_not raise_error
+        end
+      end
+
+      it "invalid_token returns empty array and hits disconnect callback" do
+        service = GooglePlusService.create(access_token: {refresh_token: "fake"}, remote_id: "410739240", user: @user, method: "Authenticated")
+        expect_any_instance_of(GooglePlusService).to receive(:disconnect).once
+        VCR.use_cassette("google_plus_service/invalid_friends_request") do
+          expect{
+            expect(service.friend_ids).to be_empty
+          }.to_not raise_error
+        end
+      end
+    end
+  end
+
+end

data/spec/models/service_spec.rb

@@ -0,0 +1,236 @@
+require 'spec_helper'
+
+module SocialAuth
+
+  describe Service do
+    before :each do
+      @user = User.create(email: "email@address.com")
+      @redis_server = Redis.new
+      allow_any_instance_of(Service).to receive(:redis_instance).and_return(@redis_server)
+    end
+
+    #service factories
+    def valid_service(user)
+      service = Service.create(access_token: {access_token: "34223"}, remote_id: "34343", user_id: user.id, method: "Authenticated")
+    end
+
+    it "has valid factory" do
+      service = valid_service(User.create())
+      expect(service).to be_valid
+    end
+
+    describe "associated_services" do
+      it "includes service with whom your friends with" do
+        service = Service.create(access_token: {fake: "fake"}, remote_id: "2", user: User.create, method: "Authenticated")
+        expect(service).to receive(:friend_ids).and_return(["1234"])
+
+        another_service = Service.create(access_token: {fake: "fake"}, remote_id: "1234", user: User.create, method: "Authenticated")
+        expect(service.services).to include another_service
+      end
+
+      it "doesn't return service your not friends with" do
+        service = Service.create(access_token: {fake: "fake"}, remote_id: "2", user: User.create, method: "Authenticated")
+        expect(service).to receive(:friend_ids).and_return(["324"])
+
+        another_service = Service.create(access_token: {fake: "fake"}, remote_id: "1234", user: User.create, method: "Authenticated")
+        expect(service.services).to_not include another_service
+      end
+    end
+
+    describe "append to friends list" do
+      before :each do
+        User.class_eval do
+          def friend_joined_the_app_callback(user)
+          end
+        end
+      end
+
+      it "append to associate_services gets called on create" do
+        expect_any_instance_of(Service).to receive(:append_to_associated_services).once
+        service = Service.create(access_token: {fake: "fake"}, remote_id: "2", user: User.create, method: "Authenticated")
+      end
+
+      it "on create append remote_id to related services" do
+        service = Service.create(access_token: {fake: "fake"}, remote_id: "2", user: User.create, method: "Authenticated")
+        @redis_server.sadd(service.redis_key(:friends), ["10", "11"])
+
+        expect(service.friend_ids.count).to eq 2
+
+        another_service = Service.create(access_token: {fake: "fake"}, remote_id: "15", user: User.create, method: "Authenticated")
+        @redis_server.sadd(another_service.redis_key(:friends), ["2"])
+
+        Service.append_to_associated_services(another_service.id)
+
+        expect(service.friend_ids.count).to eq 3
+      end
+
+      it "receives friend_join_the_app callback" do
+        expect_any_instance_of(User).to receive(:friend_joined_the_app_callback)
+
+        service = Service.create(access_token: {fake: "fake"}, remote_id: "2", user: User.create, method: "Authenticated")
+        @redis_server.sadd(service.redis_key(:friends), ["10", "11"])
+
+        expect(service.friend_ids.count).to eq 2
+
+        another_service = Service.create(access_token: {fake: "fake"}, remote_id: "15", user: User.create, method: "Authenticated")
+        @redis_server.sadd(another_service.redis_key(:friends), ["2"])
+
+        Service.append_to_associated_services(another_service.id)
+      end
+    end
+
+    describe "disconnect" do
+      before :each do
+        @service = Service.create(access_token: {access_token: "test"}, remote_id: "10204796229055532", user: @user, method: "Authenticated")
+        User.class_eval do
+          has_many :services, inverse_of: :user, class_name: SocialAuth::Service
+          def service_disconnected_callback(service)
+          end
+        end
+      end
+
+      it "destroys service if 'Connected' service" do
+        @service.update(method: 'Connected')
+        expect{
+          @service.disconnect
+        }.to change(Service, :count).by(-1)
+      end
+
+      it "doesn't destroy service if 'Authenticated' service" do
+        @service.update(method: 'Authenticated')
+        expect{
+          @service.disconnect
+        }.to raise_error InvalidToken
+      end
+
+      it "hits service disconnected callback if callback is true" do
+        @service.update(method: 'Connected')
+        expect_any_instance_of(User).to receive(:service_disconnected_callback).once
+        @service.disconnect
+      end
+
+      it "doesn't hit service disconnected callback if callback is false" do
+        @service.update(method: 'Connected')
+        expect_any_instance_of(User).to_not receive(:service_disconnected_callback).once
+        @service.disconnect(nil, false)
+      end
+    end
+
+    describe "disconnect_user" do
+      before :each do
+      end
+
+      it "disconnects service belong to user" do
+        service = Service.create(access_token: {access_token: "34223"}, remote_id: "34343", user: @user, method: "Connected")
+
+        expect_any_instance_of(Service).to receive(:disconnect).once
+        Service.disconnect_user(@user)
+      end
+
+      it "raises exception if you try to disconnect an authenticated service" do
+        service = Service.create(access_token: {access_token: "34223"}, remote_id: "34343", user: @user, method: "Authenticated")
+
+        expect{
+          Service.disconnect_user(@user)
+        }.to raise_error Error
+      end
+
+      it "raises exception if no service exists" do
+        expect{
+          Service.disconnect_user(@user)
+        }.to raise_error ServiceDoesNotExist
+      end
+    end
+
+    describe "validations" do
+      before :each do
+        @user = User.create
+      end
+
+      it "valid if 1 'Connected' of the same type exists for the same user" do
+        service = Service.new(access_token: {access_token: "34223"}, remote_id: "34343", user: @user, method: "Connected")
+        expect(service).to be_valid
+      end
+
+      it "invalid if more than 1 'Connected' of the same type exists for the same user"  do
+        service = Service.create(access_token: {access_token: "34223"}, remote_id: "34343", user: @user, method: "Connected")
+        other_service = Service.create(access_token: {access_token: "34223"}, remote_id: "34343", user: @user, method: "Connected")
+        expect(other_service).to_not be_valid
+      end
+
+      xit "can't connect a service you have already authenticated with" do
+      end
+
+      it "'Connected' service is valid if another 'Authenticated' service exists with the same remote_id but for another user" do
+        service = Service.create(access_token: {access_token: "access_token"}, remote_id: "1", user: User.create, method: "Authenticated")
+        other_service = Service.new(access_token: {access_token: "access_token"}, remote_id: "1", user: @user, method: "Connected")
+        expect(other_service).to be_valid
+      end
+
+      it "can have 1 authenticated service scoped remote_id" do
+        service = Service.new(access_token: {access_token: "34223"}, remote_id: "34343", user: @user, method: "Authenticated")
+        expect(service).to be_valid
+      end
+
+      it "cannot have multiple authenticate services with same remote_id" do
+        service = Service.create(access_token: {access_token: "fdf"}, remote_id: "34343", user: @user, method: "Authenticated")
+        another_service = Service.new(access_token: {access_token: "fdf"}, remote_id: "34343", user: @user, method: "Authenticated")
+        expect(another_service).to_not be_valid
+      end
+
+      it "can have multiple connected services with same remote_id" do
+        service = Service.create(access_token: {access_token: "fdf"}, remote_id: "34343", user: @user, method: "Connected")
+        another_service = Service.create(access_token: {access_token: "fdf"}, remote_id: "34343", user: User.create, method: "Connected")
+        expect(another_service).to be_valid
+      end
+    end
+
+    describe "self.create_with_request" do
+      def valid_service_from_request
+        Service.create_with_request("1", @user, "Authenticated",{access_token: "access_token"})
+      end
+
+      it "creates an Authenticated method service if remote id doesn't exist" do
+        expect{
+          valid_service_from_request
+        }.to change(Service, :count).by(1)
+      end
+
+      it "Can create a connected service even if an authenticated service belonging to another user already exists" do
+        service = Service.create(access_token: {access_token: "access_token"}, remote_id: "1", user: User.create, method: "Authenticated")
+        expect{
+          Service.create_with_request("1", @user, "Connected", {access_token: "access_token"})
+        }.to change(Service, :count).by(1)
+      end
+
+      it "creates service with type set to authenticated" do
+        expect(valid_service_from_request.method).to eq "Authenticated"
+      end
+
+      it "creates service if connected service already exists but belonging to another user" do
+        service = Service.create(access_token: {access_token: "access_token"}, remote_id: "1", user: @user, method: "Connected")
+        expect{
+          Service.create_with_request("1", User.create, "Connected", {access_token: "access_token"})
+        }.to change(Service, :count).by(1)
+      end
+
+      it "returns service if remote_id and method is authenticated already exist" do
+        service = Service.create(access_token: {access_token: "access_token"}, remote_id: "1", user: @user, method: "Authenticated")
+        expect{
+          expect(Service.create_with_request("1", @user, "Authenticated", {access_token: "access_token"})).to eq service
+        }.to change(Service, :count).by(0)
+      end
+
+      it "returns service if no authenticate method exists however a single connected service does exist" do
+        service = Service.create(access_token: {access_token: "access_token"}, remote_id: "1", user: @user, method: "Connected")
+          expect{
+            expect(Service.create_with_request("1", @user, "Authenticated", {access_token: "access_token"})).to eq service
+          }.to change(Service, :count).by(0)
+      end
+
+      xit "raises exception if not authentication method exists however multiple connected services exist with the same remote_id" do
+      end
+    end
+
+  end
+end