apple_dep_client 2.0.0 → 2.0.1

data/lib/apple_dep_client/hacks/typhoeus_request.rb

@@ -1,11 +1,11 @@
 # This contains a few hacks that adds support for non-ancient versions of Typhoeus to
 # the ancient dead ruby oauth gem
 
-require 'oauth/request_proxy/base'
-require 'typhoeus'
-require 'typhoeus/request'
-require 'uri'
-require 'cgi'
+require "oauth/request_proxy/base"
+require "typhoeus"
+require "typhoeus/request"
+require "uri"
+require "cgi"
 
 module OAuth::RequestProxy::Typhoeus
   class Request < OAuth::RequestProxy::Base
@@ -23,7 +23,7 @@ module OAuth::RequestProxy::Typhoeus
 
     def method
       request_method = request.options[:method].to_s.upcase
-      request_method.empty? ? 'GET' : request_method
+      request_method.empty? ? "GET" : request_method
     end
 
     def uri
@@ -47,11 +47,11 @@ module OAuth::RequestProxy::Typhoeus
 
     def post_parameters
       # Post params are only used if posting form data
-      if method == 'POST'
+      if method == "POST"
         OAuth::Helper.stringify_keys(request.params || {})
       else
         {}
       end
     end
   end
-end
+end

data/lib/apple_dep_client/profile.rb

@@ -1,6 +1,6 @@
 # Methods for getting and setting device profiles
 
-require 'json'
+require "json"
 
 module AppleDEPClient
   module Profile
@@ -10,29 +10,29 @@ module AppleDEPClient
     REMOVE_PATH = "/profile/devices"
 
     PROFILE_KEYS = [:profile_name, :url, :allow_pairing, :is_supervised,
-      :is_mandatory, :is_mdm_removable, :support_phone_number,
-      :support_email_address, :org_magic, :anchor_certs, :supervising_host_certs,
-      :skip_setup_items, :department, :devices]
+                    :is_mandatory, :is_mdm_removable, :support_phone_number,
+                    :support_email_address, :org_magic, :anchor_certs, :supervising_host_certs,
+                    :skip_setup_items, :department, :devices]
 
     def self.define(profile_data)
-      profile_data.select!{|key, value| PROFILE_KEYS.include? key.to_sym}
+      profile_data.select! { |key, _value| PROFILE_KEYS.include? key.to_sym }
       profile_data = JSON.dump profile_data
       AppleDEPClient::Request.make_request(AppleDEPClient::Request.make_url(DEFINE_PATH), :post, profile_data)
     end
 
     def self.assign(profile_uuid, devices)
-      body = {"profile_uuid" => profile_uuid, "devices" => devices}
+      body = { "profile_uuid" => profile_uuid, "devices" => devices }
       body = JSON.dump body
       AppleDEPClient::Request.make_request(AppleDEPClient::Request.make_url(ASSIGN_PATH), :put, body)
     end
 
     def self.fetch(profile_uuid)
-      params = {'profile_uuid' => profile_uuid}
-      AppleDEPClient::Request.make_request(AppleDEPClient::Request.make_url(FETCH_PATH), :get, nil, params:params)
+      params = { "profile_uuid" => profile_uuid }
+      AppleDEPClient::Request.make_request(AppleDEPClient::Request.make_url(FETCH_PATH), :get, nil, params: params)
     end
 
     def self.remove(devices)
-      body = {"devices" => devices}
+      body = { "devices" => devices }
       body = JSON.dump body
       AppleDEPClient::Request.make_request(AppleDEPClient::Request.make_url(REMOVE_PATH), :delete, body)
     end

data/lib/apple_dep_client/request.rb

@@ -1,15 +1,15 @@
 # Wrapper around requests to DEP endpoint
 # Will also handle any error conditions
 
-require 'json'
-require 'typhoeus'
+require "json"
+require "typhoeus"
 
 module AppleDEPClient
   module Request
     DEFAULT_HEADERS = {
-      'User-Agent' => "#{AppleDEPClient.user_agent}/#{AppleDEPClient::VERSION}",
-      'X-Server-Protocol-Version' => '2',
-      'Content-Type' => 'application/json;charset=UTF8',
+      "User-Agent" => "#{AppleDEPClient.user_agent}/#{AppleDEPClient::VERSION}",
+      "X-Server-Protocol-Version" => "2",
+      "Content-Type" => "application/json;charset=UTF8",
     }
     DEFAULT_HEADERS.freeze
 
@@ -31,10 +31,10 @@ module AppleDEPClient
 
     def self.make_headers
       session_auth_token = AppleDEPClient::Auth.get_session_token
-      DEFAULT_HEADERS.merge({'X-ADM-Auth-Session' => session_auth_token})
+      DEFAULT_HEADERS.merge("X-ADM-Auth-Session" => session_auth_token)
     end
 
-    def self.make_url path
+    def self.make_url(path)
       AppleDEPClient.apple_dep_server + path
     end
   end

data/lib/apple_dep_client/token.rb

@@ -1,9 +1,9 @@
 # Methods for processing DEP Server Tokens
 
-require 'json'
-require 'open3'
-require 'openssl'
-require 'tempfile'
+require "json"
+require "open3"
+require "openssl"
+require "tempfile"
 
 module AppleDEPClient
   module Token
@@ -18,13 +18,13 @@ module AppleDEPClient
     end
 
     def self.decrypt_data(smime_data)
-      data = create_temp_file('data', smime_data)
-      private_key = create_temp_file('key', AppleDEPClient.private_key)
+      data = create_temp_file("data", smime_data)
+      private_key = create_temp_file("key", AppleDEPClient.private_key)
       command = "openssl smime -decrypt -in #{data.path} -inkey #{private_key.path} -text"
       decrypted_data, errors = run_command command
       remove_temp_file data
       remove_temp_file private_key
-      if decrypted_data == '' or errors != ''
+      if decrypted_data == "" || errors != ""
         raise AppleDEPClient::Error::TokenError, "Incorrect data #{errors}"
       end
       decrypted_data
@@ -43,20 +43,20 @@ module AppleDEPClient
       file.unlink
     end
 
-    def self.run_command command
+    def self.run_command(command)
       stdin, stdout, stderr = Open3.popen3 command
       [stdout.read, stderr.read]
     end
 
     def self.parse_data(data)
       data = strip_wrappers data
-      data = JSON.parse(data, {symbolize_names: true})
+      data = JSON.parse(data, symbolize_names: true)
       save_data data
       data
     end
 
-    def self.strip_wrappers data
-      data = data.sub('-----BEGIN MESSAGE-----', '').sub('-----END MESSAGE-----', '')
+    def self.strip_wrappers(data)
+      data = data.sub("-----BEGIN MESSAGE-----", "").sub("-----END MESSAGE-----", "")
       data.strip
     end
 

data/lib/apple_dep_client/version.rb

@@ -1,3 +1,3 @@
 module AppleDEPClient
-  VERSION = "2.0.0"
+  VERSION = "2.0.1"
 end

data/spec/account_spec.rb

@@ -1,9 +1,9 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe AppleDEPClient::Account do
   it "can fetch data" do
     url = AppleDEPClient::Request.make_url(AppleDEPClient::Account::FETCH_PATH)
-    expect(AppleDEPClient::Request).to receive(:make_request).with(url, :get, '').and_return('asdf').once
-    expect(AppleDEPClient::Account.fetch).to eq 'asdf'
+    expect(AppleDEPClient::Request).to receive(:make_request).with(url, :get, "").and_return("asdf").once
+    expect(AppleDEPClient::Account.fetch).to eq "asdf"
   end
 end

data/spec/auth_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe AppleDEPClient::Auth do
   before(:each) do
@@ -6,10 +6,10 @@ describe AppleDEPClient::Auth do
   end
   before(:all) do
     AppleDEPClient.configure do |x|
-      x.consumer_key = 'consumer_key'
-      x.consumer_secret = 'consumer_secret'
-      x.access_token = 'access_token'
-      x.access_secret = 'access_secret'
+      x.consumer_key = "consumer_key"
+      x.consumer_secret = "consumer_secret"
+      x.access_token = "access_token"
+      x.access_secret = "access_secret"
     end
   end
   describe ".get_session_token" do
@@ -17,17 +17,17 @@ describe AppleDEPClient::Auth do
       expect(AppleDEPClient::Auth).to receive(:oauth_header).once.and_call_original
       expect_any_instance_of(Typhoeus::Request).to receive(:run)
       response = Typhoeus::Response.new(return_code: :ok, response_code: 200)
-      Typhoeus.stub('/apple/')
+      Typhoeus.stub("/apple/")
       expect_any_instance_of(Typhoeus::Request).to receive(:response).and_return(response)
-      expect(AppleDEPClient::Error).to receive(:check_request_error).with(response, auth:true)
-      expect(AppleDEPClient::Auth).to receive(:parse_response).with(response).and_return('asdf').once
-      expect(AppleDEPClient::Auth.get_session_token).to eq 'asdf'
+      expect(AppleDEPClient::Error).to receive(:check_request_error).with(response, auth: true)
+      expect(AppleDEPClient::Auth).to receive(:parse_response).with(response).and_return("asdf").once
+      expect(AppleDEPClient::Auth.get_session_token).to eq "asdf"
     end
   end
   describe ".parse_response" do
     let(:response) { Typhoeus::Response.new(return_code: :ok, response_code: 200, body: "{\"auth_session_token\":\"1234\"}") }
     it "will parse out the auth_session_token" do
-      expect(AppleDEPClient::Auth.parse_response response).to eq '1234'
+      expect(AppleDEPClient::Auth.parse_response response).to eq "1234"
     end
   end
 end

data/spec/callback_spec.rb

@@ -1,26 +1,26 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe AppleDEPClient::Callback do
   describe ".decode_callback" do
     it "will call decrypt_data and feed data to parse_data" do
-      expect(AppleDEPClient::Callback).to receive(:decrypt_data).with('qwer').and_return('asdf').once
-      expect(AppleDEPClient::Callback).to receive(:parse_data).with('asdf').and_return('zxcv').once
-      AppleDEPClient::Callback.decode_callback 'qwer'
+      expect(AppleDEPClient::Callback).to receive(:decrypt_data).with("qwer").and_return("asdf").once
+      expect(AppleDEPClient::Callback).to receive(:parse_data).with("asdf").and_return("zxcv").once
+      AppleDEPClient::Callback.decode_callback "qwer"
     end
   end
 
   describe ".decrypt_data" do
     it "will decrypt data and remove encryption data" do
-      expect(AppleDEPClient::Token).to receive(:create_temp_file).with('data', 'asdf', binary: true).and_call_original
-      expect(AppleDEPClient::Token).to receive(:run_command).and_return(['data', '']).once
-      expect(AppleDEPClient::Callback).to receive(:remove_encryption_data).with('data').once
-      AppleDEPClient::Callback.decrypt_data 'asdf'
+      expect(AppleDEPClient::Token).to receive(:create_temp_file).with("data", "asdf", binary: true).and_call_original
+      expect(AppleDEPClient::Token).to receive(:run_command).and_return(["data", ""]).once
+      expect(AppleDEPClient::Callback).to receive(:remove_encryption_data).with("data").once
+      AppleDEPClient::Callback.decrypt_data "asdf"
     end
     it "will raise an error if the data cannot be decrypted" do
-      expect(AppleDEPClient::Token).to receive(:create_temp_file).with('data', 'asdf', binary: true).and_call_original
-      expect(AppleDEPClient::Token).to receive(:run_command).and_return(['', 'error']).once
+      expect(AppleDEPClient::Token).to receive(:create_temp_file).with("data", "asdf", binary: true).and_call_original
+      expect(AppleDEPClient::Token).to receive(:run_command).and_return(["", "error"]).once
       expect(AppleDEPClient::Callback).to_not receive(:remove_encryption_data)
-      expect{AppleDEPClient::Callback.decrypt_data 'asdf'}.to raise_error AppleDEPClient::Error::CallbackError
+      expect { AppleDEPClient::Callback.decrypt_data "asdf" }.to raise_error AppleDEPClient::Error::CallbackError
     end
   end
 

data/spec/configuration_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe "AppleDEPClient::Configuration" do
   it "has a default apple_dep_server value" do
@@ -6,49 +6,49 @@ describe "AppleDEPClient::Configuration" do
   end
 
   it "can be configured" do
-    AppleDEPClient.private_key = 'asdf'
-    AppleDEPClient.consumer_key = 'qwer'
-    expect(AppleDEPClient.private_key).to eq 'asdf'
-    expect(AppleDEPClient.consumer_key).to eq 'qwer'
+    AppleDEPClient.private_key = "asdf"
+    AppleDEPClient.consumer_key = "qwer"
+    expect(AppleDEPClient.private_key).to eq "asdf"
+    expect(AppleDEPClient.consumer_key).to eq "qwer"
   end
 
   describe ".method_missing" do
     it "can get value for valid configuration keys" do
-      expect(AppleDEPClient).to receive(:get_value).with(:access_token).and_return 'asdf'
-      expect(AppleDEPClient.access_token).to eq 'asdf'
+      expect(AppleDEPClient).to receive(:get_value).with(:access_token).and_return "asdf"
+      expect(AppleDEPClient.access_token).to eq "asdf"
     end
     it "can raise NoMethodError for invalid configuration keys" do
-      expect{AppleDEPClient.asdf}.to raise_error NoMethodError
+      expect { AppleDEPClient.asdf }.to raise_error NoMethodError
     end
   end
 
   describe ".get_value" do
     it "can get a configuration value directly from the saved value" do
-      AppleDEPClient.private_key = 'qwer'
-      expect(AppleDEPClient.private_key).to eq 'qwer'
+      AppleDEPClient.private_key = "qwer"
+      expect(AppleDEPClient.private_key).to eq "qwer"
     end
     it "will get the default value if the instance variable isn't set" do
       expect(AppleDEPClient.apple_dep_server).to_not be_nil
     end
     it "can get a configuration value by calling a Proc" do
-      AppleDEPClient.private_key = lambda { return 'qwer' }
-      expect(AppleDEPClient.private_key).to eq 'qwer'
+      AppleDEPClient.private_key = lambda { return "qwer" }
+      expect(AppleDEPClient.private_key).to eq "qwer"
     end
   end
 
   describe ".get_default_value" do
     it "will read the default value from DEP_CONFIG" do
       apple_dep_server = AppleDEPClient::Configuration::DEP_CONFIG[:apple_dep_server]
-      expect(AppleDEPClient.get_default_value('apple_dep_server')).to eq apple_dep_server
+      expect(AppleDEPClient.get_default_value("apple_dep_server")).to eq apple_dep_server
     end
   end
 
   describe ".configure" do
     it "can be configured in a block" do
       AppleDEPClient.configure do |x|
-        x.private_key = 'asdf'
+        x.private_key = "asdf"
       end
-      expect(AppleDEPClient.private_key).to eq 'asdf'
+      expect(AppleDEPClient.private_key).to eq "asdf"
     end
   end
 end

data/spec/device_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe AppleDEPClient::Device do
   describe ".fetch" do
@@ -6,47 +6,47 @@ describe AppleDEPClient::Device do
       @url = AppleDEPClient::Device::FETCH_PATH
     end
     it "will iterate through data to yield devices" do
-      response = {'cursor' => 'asdf', 'devices' => ['qwer', 'zxcv'], 'more_to_follow' => 'false'}
+      response = { "cursor" => "asdf", "devices" => ["qwer", "zxcv"], "more_to_follow" => "false" }
       expect(AppleDEPClient::Device).to receive(:make_fetch_request).with(nil, @url).and_return(response).once
       devices = []
-      AppleDEPClient::Device.fetch{|x| devices << x }
-      expect(devices).to eq ['qwer', 'zxcv']
+      AppleDEPClient::Device.fetch { |x| devices << x }
+      expect(devices).to eq ["qwer", "zxcv"]
     end
     it "will iterate through multiple responses" do
-      response = {'cursor' => '1', 'devices' => ['qwer'], 'more_to_follow' => 'true'}
+      response = { "cursor" => "1", "devices" => ["qwer"], "more_to_follow" => "true" }
       expect(AppleDEPClient::Device).to receive(:make_fetch_request).with(nil, @url).and_return(response).once
-      response = {'cursor' => '2', 'devices' => ['zxcv'], 'more_to_follow' => 'false'}
-      expect(AppleDEPClient::Device).to receive(:make_fetch_request).with('1', @url).and_return(response).once
+      response = { "cursor" => "2", "devices" => ["zxcv"], "more_to_follow" => "false" }
+      expect(AppleDEPClient::Device).to receive(:make_fetch_request).with("1", @url).and_return(response).once
       devices = []
-      AppleDEPClient::Device.fetch{|x| devices << x }
-      expect(devices).to eq ['qwer', 'zxcv']
+      AppleDEPClient::Device.fetch { |x| devices << x }
+      expect(devices).to eq ["qwer", "zxcv"]
     end
     it "will return the last cursor" do
-      response = {'cursor' => '1', 'devices' => ['qwer'], 'more_to_follow' => 'true'}
+      response = { "cursor" => "1", "devices" => ["qwer"], "more_to_follow" => "true" }
       expect(AppleDEPClient::Device).to receive(:make_fetch_request).with(nil, @url).and_return(response).once
-      response = {'cursor' => '2', 'devices' => ['zxcv'], 'more_to_follow' => 'false'}
-      expect(AppleDEPClient::Device).to receive(:make_fetch_request).with('1', @url).and_return(response).once
-      cursor = AppleDEPClient::Device.fetch{}
-      expect(cursor).to eq '2'
+      response = { "cursor" => "2", "devices" => ["zxcv"], "more_to_follow" => "false" }
+      expect(AppleDEPClient::Device).to receive(:make_fetch_request).with("1", @url).and_return(response).once
+      cursor = AppleDEPClient::Device.fetch {}
+      expect(cursor).to eq "2"
     end
   end
 
   describe ".make_fetch_request" do
     it "will make a request" do
-      expect(AppleDEPClient::Device).to receive(:fetch_body).with('cursor').and_return 'body'
+      expect(AppleDEPClient::Device).to receive(:fetch_body).with("cursor").and_return "body"
       url = AppleDEPClient::Request.make_url(AppleDEPClient::Device::FETCH_PATH)
-      expect(AppleDEPClient::Request).to receive(:make_request).with(url, :post, 'body').and_return('response').once
-      expect(AppleDEPClient::Device.make_fetch_request 'cursor', AppleDEPClient::Device::FETCH_PATH).to eq 'response'
+      expect(AppleDEPClient::Request).to receive(:make_request).with(url, :post, "body").and_return("response").once
+      expect(AppleDEPClient::Device.make_fetch_request "cursor", AppleDEPClient::Device::FETCH_PATH).to eq "response"
     end
   end
 
   describe ".fetch_body" do
     it "will create a body to send" do
-      body = {'limit' => AppleDEPClient::Device::FETCH_LIMIT, 'cursor' => 'asdf'}
-      expect(JSON.parse(AppleDEPClient::Device.fetch_body 'asdf')).to eq body
+      body = { "limit" => AppleDEPClient::Device::FETCH_LIMIT, "cursor" => "asdf" }
+      expect(JSON.parse(AppleDEPClient::Device.fetch_body "asdf")).to eq body
     end
     it "won't sent a cursor if it's not specified" do
-      body = {'limit' => AppleDEPClient::Device::FETCH_LIMIT}
+      body = { "limit" => AppleDEPClient::Device::FETCH_LIMIT }
       expect(JSON.parse(AppleDEPClient::Device.fetch_body nil)).to eq body
     end
   end
@@ -56,35 +56,35 @@ describe AppleDEPClient::Device do
       @url = AppleDEPClient::Device::SYNC_PATH
     end
     it "will use a cursor and return results" do
-      response = {'cursor' => '2', 'devices'=>['zxcv'], 'more_to_follow' => 'false'}
-      expect(AppleDEPClient::Device).to receive(:make_fetch_request).with('1', @url).and_return(response).once
+      response = { "cursor" => "2", "devices" => ["zxcv"], "more_to_follow" => "false" }
+      expect(AppleDEPClient::Device).to receive(:make_fetch_request).with("1", @url).and_return(response).once
       devices = []
-      AppleDEPClient::Device.sync('1'){|x| devices << x }
-      expect(devices).to eq ['zxcv']
+      AppleDEPClient::Device.sync("1") { |x| devices << x }
+      expect(devices).to eq ["zxcv"]
     end
     it "will return a new cursor" do
-      response = {'cursor' => '2', 'devices'=>['zxcv'], 'more_to_follow' => 'false'}
-      expect(AppleDEPClient::Device).to receive(:make_fetch_request).with('1', @url).and_return(response).once
-      cursor = AppleDEPClient::Device.sync('1'){}
-      expect(cursor).to eq '2'
+      response = { "cursor" => "2", "devices" => ["zxcv"], "more_to_follow" => "false" }
+      expect(AppleDEPClient::Device).to receive(:make_fetch_request).with("1", @url).and_return(response).once
+      cursor = AppleDEPClient::Device.sync("1") {}
+      expect(cursor).to eq "2"
     end
   end
 
   describe ".details" do
     it "will return details of devices" do
-      devices = ['asdf']
-      expect(AppleDEPClient::Request).to receive(:make_request).and_return({"devices" => {"asdf"=>"data"}})
+      devices = ["asdf"]
+      expect(AppleDEPClient::Request).to receive(:make_request).and_return("devices" => { "asdf" => "data" })
       devices = AppleDEPClient::Device.details devices
-      expect(devices).to eq({"asdf" => "data"})
+      expect(devices).to eq("asdf" => "data")
     end
   end
 
   describe ".disown" do
     it "will make a request to disown devices" do
-      devices = ['asdf']
-      expect(AppleDEPClient::Request).to receive(:make_request).and_return({"devices" => {"asdf"=>"SUCCESS"}})
+      devices = ["asdf"]
+      expect(AppleDEPClient::Request).to receive(:make_request).and_return("devices" => { "asdf" => "SUCCESS" })
       devices = AppleDEPClient::Device.disown devices
-      expect(devices).to eq({"asdf" => "SUCCESS"})
+      expect(devices).to eq("asdf" => "SUCCESS")
     end
   end
 end