wavelabs_client_api 0.3.5

data/lib/wavelabs_client_api/client/api/data_models/message_api_model.rb

@@ -0,0 +1,19 @@
+# This class is a virtual Model for MessageApi model.
+# It have required attributes to create the MessageApi model object.
+# The purpose of this class is to create MessageApi model object
+# to send back the API Server response. 
+
+
+class WavelabsClientApi::Client::Api::DataModels::MessageApiModel
+
+  attr_accessor :status, :messgeCode, :message
+
+  def initialize(json_response = nil)
+  	if json_response.present?
+	  	@status = json_response.code 
+	  	@messageCode = json_response.parsed_response[:messageCode]
+	  	@message = json_response.parsed_response[:message]
+	  end	
+  end
+
+end	

data/lib/wavelabs_client_api/client/api/data_models/social_accounts_api_model.rb

@@ -0,0 +1,41 @@
+# This class is a virtual Model for SocialAccountsApiModel.
+# It have required attributes to create the SocialAccountsApiModel object.
+# And also it included the Rails ActiveModel::Validations to 
+# add errors which will populate on views. Based on the response from
+# Wavelabs API server 'add_errors' or 'add_messages' methods add appropriate
+# messages to SocialAccountsApiModel object.
+
+class WavelabsClientApi::Client::Api::DataModels::SocialAccountsApiModel < WavelabsClientApi::Client::Api::DataModels::BaseApiModel
+
+  attr_accessor :id, :email, :social_type, :image_url
+
+  def initialize(social_params = nil)
+    if social_params.present?
+      @id = social_params["id"]
+      @email = social_params["email"]
+      @social_type = social_params["socialType"]
+      @image_url = social_params["imageUrl"]
+    else
+      @id, @email, @social_type, @image_url = nil
+    end
+  end
+
+
+  def add_errors(json_response)
+    json_response["errors"].each do |e| 
+      property_name = e['propertyName']
+      msg = e['message']  
+      self.errors[property_name] << msg
+    end   
+  end
+
+  def add_messages(json_response)
+    if json_response["message"].present?
+      @message = json_response["message"]
+    elsif json_response["error"].present?
+      @message = json_response["error"]
+    end  
+          
+  end
+
+end

data/lib/wavelabs_client_api/client/api/data_models/token_api_model.rb

@@ -0,0 +1,37 @@
+# This class is a virtual Model for TokenApiModel.
+# It have required attributes to create the TokenApiModel object.
+
+
+class WavelabsClientApi::Client::Api::DataModels::TokenApiModel < WavelabsClientApi::Client::Api::DataModels::BaseApiModel
+  attr_accessor :value, :expires_in, :refresh_token, :scope, :token_type, :message
+
+  def initialize(token_params = nil)
+  	if token_params.present? 
+	    @value = token_params["access_token"]
+	    @expires_in = token_params["expires_in"]
+	    @refresh_token = token_params["refresh_token"]
+	    @scope = token_params["scope"]
+	    @token_type = token_params["token_type"]
+	  else
+	  	@value , @expires_in, @refresh_token, @scope, @token_type, @message = nil
+	  end    
+  end
+
+  def add_errors(json_response)
+    json_response["errors"].each do |e| 
+      property_name = e['propertyName']
+      msg = e['message']  
+      self.errors[property_name] << msg
+    end   
+  end
+
+  def add_messages(json_response)
+    if json_response["message"].present?
+      @message = json_response["message"]
+    elsif json_response["error"].present?
+      @message = json_response["error"]
+    end  
+          
+  end
+
+end

data/lib/wavelabs_client_api/client/api/data_models/token_details_api_model.rb

@@ -0,0 +1,51 @@
+# This class is a virtual Model for TokenApiModel.
+# It have required attributes to create the TokenApiModel object.
+
+
+class WavelabsClientApi::Client::Api::DataModels::TokenDetailsApiModel < WavelabsClientApi::Client::Api::DataModels::BaseApiModel
+  attr_accessor :username, :clientId, :tokenType, :token, :expiration, :expired, :authorities, :uuid, :tenantId, :message
+
+  def initialize(token_details_params = nil)
+  	if token_details_params.present? 
+	    @username = token_details_params["username"]
+	    @expiration = token_details_params["expiration"]
+	    @clientId = token_details_params["clientId"]
+	    @token = token_details_params["token"]
+	    @tokenType = token_details_params["tokenType"]
+      @expired = token_details_params["expired"]
+      if token_details_params["member"].present?
+        @uuid = token_details_params["member"]["uuid"]
+      else
+        @uuid = nil 
+      end
+
+      if token_details_params["authorities"].present?
+        @authorities = token_details_params["authorities"]
+      else
+        @authorities = nil
+      end
+
+      @tenantId = token_details_params["tenantId"]
+	  else
+	  	@username, @expiration, @clientId, @token, @tokenType, @expired, @authorities, @uuid, @tenantId= nil
+	  end    
+  end
+
+  def add_errors(json_response)
+    json_response["errors"].each do |e| 
+      property_name = e['propertyName']
+      msg = e['message']  
+      self.errors[property_name] << msg
+    end   
+  end
+
+  def add_messages(json_response)
+    if json_response["message"].present?
+      @message = json_response["message"]
+    elsif json_response["error"].present?
+      @message = json_response["error"]
+    end  
+          
+  end
+
+end

data/lib/wavelabs_client_api/version.rb

@@ -0,0 +1,3 @@
+module WavelabsClientApi
+  VERSION = "0.3.5"
+end

data/spec/core_api_specs/auth_api_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe WavelabsClientApi::Client::Api::Core::AuthApi do
+
+  user_params = {:username => "wavlelabstest", 
+                          :password => "test123",
+                          :email => "test@wavelabs.com",
+                          :firstName => "w",
+                          :lastName => "L"}
+
+  let(:signup_user) {UserSignUp.sign_up_user(user_params)}
+  let(:login_user) {UserSignUp.login_user}
+  let(:get_initial_token) {UserSignUp.get_token}
+
+	let (:auth_api_obj) { WavelabsClientApi::Client::Api::Core::AuthApi.new}
+  let (:auth_api) { WavelabsClientApi::Client::Api::Core::AuthApi}
+
+  it "#check_connection?" do
+    expect(auth_api.check_connection?).to be true
+  end 
+
+  it "#Check Constants of Auth API URIS" do
+  	expect(auth_api::AUTH_TOKEN_URI).to eq '/oauth/token'
+    expect(auth_api::TOKEN_VALIDATION_URI).to eq '/api/oauth/v0/tokens'
+    expect(auth_api::LOGIN_URI).to eq '/api/identity/v0/auth/login'
+    expect(auth_api::LOGOUT_URI).to eq '/api/identity/v0/auth/logout'
+    expect(auth_api::CHANGE_PASSWORD_URI).to eq '/api/identity/v0/auth/changePassword'
+    expect(auth_api::FORGOT_PASSWORD_URI).to eq '/api/identity/v0/auth/forgotPassword'
+  end
+
+  it "#get_auth_token with client details" do
+    res = auth_api_obj.get_auth_token("client_credentials", "scope:oauth.token.verify")
+    expect(res[:status]).to eq 200
+  end 
+
+  it "#is_token_valid with valid tokens" do
+    signup_user
+    res = auth_api_obj.login({:username => "wavlelabstest", :password => "test123"}, get_initial_token)
+    expect(res[:status]).to eq 200
+    user_token = res[:member].token.value
+    final_res = auth_api_obj.is_token_valid(user_token, get_initial_token)
+    #expect(final_res[:token].token).not_to be_empty
+    expect(final_res[:status]).to eq 403
+  end 
+
+  it "#login method without login details" do
+  	res = auth_api_obj.login
+  	expect(res[:status]).to eq 500
+  	expect(res[:login].message).to eq "Invalid login parameters"
+  end
+
+  it "#login method with unregistered login details" do
+  	res = auth_api_obj.login({:username => "test", :password => "pas"}, get_initial_token)
+  	expect(res[:status]).to eq 400
+  end
+
+  it "#login method with registered login details" do
+  	signup_user
+  	res = auth_api_obj.login({:username => "wavlelabstest", :password => "test123"}, get_initial_token)
+  	expect(res[:status]).to eq 200
+  end
+
+  it "Check Forgot Password with valid email#forgot_password" do
+  	res = auth_api_obj.forgot_password({:email => "test@wavelabs.com"}, get_initial_token)
+  	expect(res[:status]).to eq 200
+  end
+
+  it "Check Forgot Password with invalid email(#forgot_password)" do
+  	res = auth_api_obj.forgot_password({:email => "test@labs.com"}, get_initial_token)
+  	expect(res[:status]).to eq 400
+  end
+
+  it "Check Forgot Password with empty email(#forgot_password)" do
+  	res = auth_api_obj.forgot_password({:email => " "}, get_initial_token)
+  	expect(res[:status]).to eq 400
+  end
+
+  it "Check Change Password with invalid details(#change_password)" do
+    l_req = login_user
+    res = auth_api_obj.change_password({:password => "", :newPassword =>  " "},l_req[:member].token.value)
+    expect(res[:status]).to eq 400
+  end
+
+  it "Check Logout(#logout)" do
+  	l_req = login_user
+  	res = auth_api_obj.logout(l_req[:member].token.value)
+  	expect(res[:status]).to eq 200
+  end	
+  	
+end

data/spec/core_api_specs/media_api_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe WavelabsClientApi::Client::Api::Core::MediaApi do
+	let(:login_user) {UserSignUp.login_user}
+
+	let (:media_api_obj) { WavelabsClientApi::Client::Api::Core::MediaApi.new}
+  let (:media_api) { WavelabsClientApi::Client::Api::Core::MediaApi}
+
+  it "#check_connection?" do
+    expect(media_api.check_connection?).to be true
+  end
+
+  it "#Check Constants of Media API URIS" do
+    expect(media_api::MEDIA_URI).to eq '/api/media/v0/media'
+  end
+
+  it "#get_media with user details after login" do
+  	l_req = login_user
+  	res = media_api_obj.get_media(l_req[:member].id, "profile", l_req[:member].token.value)
+    expect(res[:status]).to eq 200
+  end
+
+  it "#update_media with user details after login" do
+  	l_req = login_user
+  	file_path = Dir.pwd + "/spec/support/temp_user.png"
+  	res = media_api_obj.upload_media(file_path, "profile", l_req[:member].token.value, l_req[:member].id)
+    expect(res[:status]).to eq 200
+  end
+
+  it "#update_media with invalide file type after login" do
+  	l_req = login_user
+  	file_path = Dir.pwd + "/spec/support/temp_user.doc"
+  	res = media_api_obj.upload_media(file_path, "profile", l_req[:member].token.value, l_req[:member].id)
+    expect(res[:status]).to eq 200
+    expect(res[:media].message).to eq "media.upload.error"
+  end		
+
+end	

data/spec/core_api_specs/social_api_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe WavelabsClientApi::Client::Api::Core::SocialApi do
+	let (:social_api_obj) { WavelabsClientApi::Client::Api::Core::SocialApi.new}
+  let (:social_api) { WavelabsClientApi::Client::Api::Core::SocialApi}
+
+  it "#check_connection?" do
+    expect(social_api.check_connection?).to be true
+  end 
+
+  it "#Check Constants of Social API URIS" do
+  	expect(social_api::FACEBOOK_LOGIN_URI).to eq '/api/identity/v0/auth/social/facebook/connect'
+    expect(social_api::GOOGLE_LOGIN_URI).to eq '/api/identity/v0/auth/social/googlePlus/connect'
+    expect(social_api::GITHUB_LOGIN_URI).to eq '/api/identity/v0/auth/social/gitHub/connect'
+    expect(social_api::LINKEDIN_LOGIN_URI).to eq '/api/identity/v0/auth/social/linkedIn/connect'
+    expect(social_api::INSTAGRAM_LOGIN_URI).to eq '/api/identity/v0/auth/social/instagram/connect'
+    expect(social_api::TWITER_LOGIN_URI).to eq '/api/identity/v0/auth/social/twitter/connect'
+    expect(social_api::INVALID_SOCIAL_URI).to eq '/api/identity/v0/auth/social/invalid/connect'
+  end
+
+  it "#get_scoial_login_uri" do
+  	expect(social_api_obj.get_scoial_login_uri("facebook")).to eq '/api/identity/v0/auth/social/facebook/connect'
+  	expect(social_api_obj.get_scoial_login_uri("google_oauth2")).to eq '/api/identity/v0/auth/social/googlePlus/connect'
+  	expect(social_api_obj.get_scoial_login_uri("linkedin")).to eq '/api/identity/v0/auth/social/linkedIn/connect'
+  	expect(social_api_obj.get_scoial_login_uri("instagram")).to eq '/api/identity/v0/auth/social/instagram/connect'
+  	expect(social_api_obj.get_scoial_login_uri("twitter")).to eq '/api/identity/v0/auth/social/twitter/connect'
+  	expect(social_api_obj.get_scoial_login_uri("github")).to eq '/api/identity/v0/auth/social/gitHub/connect'
+    expect(social_api_obj.get_scoial_login_uri("abcdef")).to eq '/api/identity/v0/auth/social/invalid/connect'
+  end	
+
+
+end	

data/spec/core_api_specs/users_api_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe WavelabsClientApi::Client::Api::Core::UsersApi do
+
+  let (:user_api_obj) { WavelabsClientApi::Client::Api::Core::UsersApi.new}
+  let (:user_api) { WavelabsClientApi::Client::Api::Core::UsersApi}
+  let(:get_initial_token) {UserSignUp.get_token}
+
+  let(:login_user) {UserSignUp.login_user}
+  
+  it "check server connection" do
+    expect(user_api.check_connection?).to be true
+  end 
+
+  
+  it "#Check Constants of Users API URIS" do
+    expect(user_api::SIGNUP_URI).to eq '/api/identity/v0/users/signup'
+    expect(user_api::USER_URI).to eq '/api/identity/v0/users'
+  end
+
+
+  it "Signup with existing user details(#sign_up)" do
+    user_params = {:username => "wavlelabstest", 
+                          :password => "test123",
+                          :email => "test@wavelabs.com",
+                          :firstName => "w",
+                          :lastName => "L"}
+
+    res = user_api_obj.sign_up(user_params, get_initial_token)
+    expect(res[:status]).to eq 400
+    expect(res[:member].errors.size).to eq 2
+
+  end
+
+  it "Signup with valid details(#sign_up)" do
+    random_number = rand(0..100)
+    user_params = {:username => "wavlelabstest#{random_number}", 
+                          :password => "test1234",
+                          :email => "test@wavelabs#{random_number}.com",
+                          :firstName => "L",
+                          :lastName => "W"}
+
+    res = user_api_obj.sign_up(user_params, get_initial_token)
+    expect([200,400].include?res[:status]).to eq true
+  end
+
+  it "After Login user can view his profile(#show)" do
+    l_req = login_user
+    res = user_api_obj.show({:id => l_req[:member].id},l_req[:member].token.value)
+    expect(res[:status]).to eq 200
+  end
+
+  it "After Login user can update his profile(#update)" do
+    l_req = login_user
+    edit_user_params = {:id => l_req[:member].id, 
+                        :description => "test wavelabs",
+                        :email => "test@wavelabs.com",
+                        :firstName => "W",
+                        :lastName => "L"
+                       }
+    res = user_api_obj.update(edit_user_params,l_req[:member].token.value)
+    expect(res[:status]).to eq 200
+  end
+  	
+end

data/spec/data_model_specs/login_api_model_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe WavelabsClientApi::Client::Api::DataModels::LoginApiModel do
+
+	let (:login_api_model_obj) { WavelabsClientApi::Client::Api::DataModels::LoginApiModel.new}
+  let (:login_api_model) { WavelabsClientApi::Client::Api::DataModels::LoginApiModel}
+
+  it "#check all model properties" do
+    expect(login_api_model_obj.respond_to?(:username)).to eq true
+    expect(login_api_model_obj.respond_to?(:email)).to eq true
+    expect(login_api_model_obj.respond_to?(:firstName)).to eq true
+    expect(login_api_model_obj.respond_to?(:lastName)).to eq true
+    expect(login_api_model_obj.respond_to?(:phone)).to eq true
+    expect(login_api_model_obj.respond_to?(:newPassword)).to eq true
+    expect(login_api_model_obj.respond_to?(:message)).to eq true
+  end
+
+  it "#check all instance methods" do
+    expect(login_api_model_obj.respond_to?(:add_errors)).to eq true
+    expect(login_api_model_obj.respond_to?(:add_messages)).to eq true
+  end
+
+  it "#check undefined instance/properties methods" do
+    expect(login_api_model_obj.respond_to?(:description)).to eq false
+    expect(login_api_model_obj.respond_to?(:add_message)).to eq false
+  end
+end	

data/spec/data_model_specs/media_api_model_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe WavelabsClientApi::Client::Api::DataModels::MediaApiModel do
+
+	let (:media_api_model_obj) { WavelabsClientApi::Client::Api::DataModels::MediaApiModel.new()}
+  let (:media_api_model) { WavelabsClientApi::Client::Api::DataModels::MediaApiModel}
+
+  it "#check all model properties" do
+    expect(media_api_model_obj.respond_to?(:extension)).to eq true
+    expect(media_api_model_obj.respond_to?(:mediaFileDetailsList)).to eq true
+    expect(media_api_model_obj.respond_to?(:newMedia)).to eq true
+    expect(media_api_model_obj.respond_to?(:supportedsizes)).to eq true
+    expect(media_api_model_obj.respond_to?(:message)).to eq true
+  end
+
+  it "#check undefined instance/properties methods" do
+    expect(media_api_model_obj.respond_to?(:password)).to eq false
+    expect(media_api_model_obj.respond_to?(:add_message)).to eq false
+  end
+
+end	

data/spec/data_model_specs/member_api_model_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe WavelabsClientApi::Client::Api::DataModels::MemberApiModel do
+
+	let (:member_api_model_obj) { WavelabsClientApi::Client::Api::DataModels::MemberApiModel.new(nil, true)}
+  let (:member_api_model_obj_with_associates) { WavelabsClientApi::Client::Api::DataModels::MemberApiModel.new(nil, false)}
+  let (:member_api_model) { WavelabsClientApi::Client::Api::DataModels::MemberApiModel}
+
+  it "#check all model properties" do
+    expect(member_api_model_obj.respond_to?(:username)).to eq true
+    expect(member_api_model_obj.respond_to?(:email)).to eq true
+    expect(member_api_model_obj.respond_to?(:firstName)).to eq true
+    expect(member_api_model_obj.respond_to?(:lastName)).to eq true
+    expect(member_api_model_obj.respond_to?(:phone)).to eq true
+    expect(member_api_model_obj.respond_to?(:id)).to eq true
+    expect(member_api_model_obj.respond_to?(:description)).to eq true
+    expect(member_api_model_obj.respond_to?(:message)).to eq true
+  end
+
+  it "#check all instance methods" do
+    expect(member_api_model_obj.respond_to?(:add_errors)).to eq true
+    expect(member_api_model_obj.respond_to?(:add_messages)).to eq true
+  end
+
+  it "#check undefined instance/properties methods" do
+    expect(member_api_model_obj.respond_to?(:password)).to eq false
+    expect(member_api_model_obj.respond_to?(:add_message)).to eq false
+  end
+
+
+  it "#check assoicated models of member" do
+    m_model = member_api_model_obj_with_associates
+
+    expect(m_model.respond_to?(:social_accounts)).to eq true
+    expect(m_model.respond_to?(:token)).to eq true
+  end
+
+end