Introduce Forbidden and InvalidCredentials errors

lib/easee/client.rb

@@ -79,13 +79,13 @@ def connection
       Faraday.new(url: BASE_URL) do |conn|
         conn.request :json
         conn.response :raise_error
+        conn.response :json, content_type: /\bjson$/
       end
     end
 
     def authenticated_connection
       connection.tap do |conn|
         conn.request :authorization, "Bearer", access_token
-        conn.response :json, content_type: /\bjson$/
       end
     end
 
@@ -116,17 +116,21 @@ def with_error_handling
 
         retry
       end
+    rescue Faraday::TooManyRequestsError => e
+      raise Errors::RateLimitExceeded.new("Rate limit exceeded", e.response)
+    rescue Faraday::ForbiddenError => e
+      raise Errors::Forbidden, "Access denied to charger"
     rescue Faraday::Error => e
-      if e.response_status == 429 # HTTP 429 TooManyRequests
-        raise Errors::RateLimitExceeded.new("Rate limit exceeded", e.response)
-      else
-        raise Errors::RequestFailed.new("Request returned status #{e.response_status}", e.response)
+      if e.response_status == 400 && e.response.dig(:body, "errorCode") == 100
+        raise Errors::InvalidCredentials, "Invalid username or password"
       end
+
+      raise Errors::RequestFailed.new("Request returned status #{e.response_status}", e.response)
     end
 
     def access_token
       encrypted_tokens = @token_cache.fetch(TOKENS_CACHE_KEY) do
-        @encryptor.encrypt(request_access_token, cipher_options: { deterministic: true })
+        @encryptor.encrypt(request_access_token.to_json, cipher_options: { deterministic: true })
       end
 
       plain_text_tokens = @encryptor.decrypt(encrypted_tokens)
@@ -137,7 +141,7 @@ def access_token
     def refresh_access_token!
       @token_cache.write(
         TOKENS_CACHE_KEY,
-        @encryptor.encrypt(refresh_access_token, cipher_options: { deterministic: true }),
+        @encryptor.encrypt(refresh_access_token.to_json, cipher_options: { deterministic: true }),
         expires_in: 1.day,
       )
     rescue Faraday::Error => e

lib/easee/errors.rb

@@ -4,6 +4,8 @@ class Base < ::StandardError
       def retryable? = false
     end
 
+    class InvalidCredentials < Base; end
+
     class RequestFailed < Base
       attr_reader :response
 
@@ -13,6 +15,8 @@ def initialize(message, response = nil)
       end
     end
 
+    class Forbidden < Base; end
+
     class RateLimitExceeded < RequestFailed
       def retryable? = true
     end

spec/easee/client_spec.rb

@@ -153,6 +153,35 @@
       expect(encryptor).to have_received(:encrypt).with(tokens.to_json, cipher_options: { deterministic: true })
       expect(encryptor).to have_received(:decrypt).with("encrypted")
     end
+
+    it "raises when the access token could not be obtained" do
+      user_name = "test"
+      password = "wrong"
+
+      stub_request(:post, "https://api.easee.cloud/api/accounts/login")
+        .with(
+          body: { userName: user_name, password: }.to_json,
+        )
+        .to_return(
+          status: 400,
+          body: {
+            errorCode: 100,
+            errorCodeName: "InvalidUserPassword",
+            type: nil,
+            title: "Username or password is invalid",
+            status: 400,
+            detail: "[Empty in production]",
+            instance: nil,
+            extensions: {},
+          }.to_json,
+          headers: { "Content-Type": "application/json" },
+        )
+
+      client = Easee::Client.new(user_name:, password:)
+
+      expect { client.pair(charger_id: "123ABC", pin_code: "1234") }
+        .to raise_error(Easee::Errors::InvalidCredentials)
+    end
   end
 
   describe "#pair" do
@@ -374,6 +403,21 @@
         expect(error).to be_retryable
       end
     end
+
+    it "raises a Forbidden error when we have no access to the charger (anymore)" do
+      stub_request(:get, "https://api.easee.cloud/api/chargers/C123/state")
+        .to_return(status: 403)
+
+      token_cache = ActiveSupport::Cache::MemoryStore.new
+      token_cache.write(
+        Easee::Client::TOKENS_CACHE_KEY,
+        { "accessToken" => "T123" }.to_json,
+      )
+
+      client = Easee::Client.new(user_name: "easee", password: "money", token_cache:)
+
+      expect { client.state("C123") }.to raise_error(Easee::Errors::Forbidden)
+    end
   end
 
   describe "#pause_charging" do