nexus_mods 2.1.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac9b76be57a989b2cd00cb120912dc8360fc926e76589769b725879f582e7d82
-  data.tar.gz: 61342738bb1678bdbbbf350bf645b90210c55c8b53a63bdbb9cc755ca6f146bd
+  metadata.gz: 0d5efb3b98f3d8b66565eff56b7b6360fc99bae69a256423e6eae391eb3cd676
+  data.tar.gz: 7091d96c8a79ec591e805bcc09958199187b5f0afd73de85b5da314c2e24381a
 SHA512:
-  metadata.gz: 8ad0436dd7917b94ebbedaa26e7f943a92520b0336413730e273108849b7f2659e026954ad1a68570e99c27ad6654a6c970be208ec500078a4490e65930ce896
-  data.tar.gz: 67a49c5e42db887253894726eed4b7ff3adde7f6da0f31d123ce6587117abb99d80a26e9a0db69bb541368fec4c6561b3b0a9564a8fe5ac27a412b0fb3c0173e
+  metadata.gz: 1485e5270d8fcffb7a2ebfec15848f0f2af3a2575beef6b2d1c4746af682bd13142d15f140adae1c9e7c15d731d85d63d01ec135f28600e73d58249bc130990e
+  data.tar.gz: eccb9f4312f63a8c8fc459592c4c0c618378f59a69a261512981e890c0bfffa8c2044bafbcd16da9ec9c8d3b980a53a2e5322a89c5eece959240cafb7ac05e19

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+# [v2.3.0](https://github.com/Muriel-Salvan/nexus_mods/compare/v2.2.0...v2.3.0) (2023-04-12 15:08:22)
+
+### Features
+
+* [[Feature] Add a way to set cache timestamps manually](https://github.com/Muriel-Salvan/nexus_mods/commit/7e5ac1d16d1d31f4aa33ebb9a748310e4572a06f)
+
+# [v2.2.0](https://github.com/Muriel-Salvan/nexus_mods/compare/v2.1.0...v2.2.0) (2023-04-12 12:56:31)
+
+### Features
+
+* [[Feature] Add possibility to retrieve the cache timestamp of API resources](https://github.com/Muriel-Salvan/nexus_mods/commit/ba67323a32472deb1f063a51683ff9282ef96981)
+
 # [v2.1.0](https://github.com/Muriel-Salvan/nexus_mods/compare/v2.0.1...v2.1.0) (2023-04-11 18:24:04)
 
 ### Features

data/lib/nexus_mods/api_client.rb

@@ -60,6 +60,37 @@ class NexusMods
       cached_api(path, parameters:, verb:)
     end
 
+    # Get the timestamp of the cached data linked to a given API call
+    #
+    # Parameters::
+    # * *path* (String): API path to contact (from v1/ and without .json)
+    # * *parameters* (Hash<Symbol,Object>): Optional parameters to add to the path [default: {}]
+    # * *verb* (Symbol): Verb to be used (:get, :post...) [default: :get]
+    # Result::
+    # * Time or nil: The refresh time of the data, or nil if not part of the cache
+    def api_cache_timestamp(path, parameters: {}, verb: :get)
+      key = ApiClient.cache_key(path, parameters:, verb:)
+      return unless Cacheable.cache_adapter.exist?(key)
+
+      str_time = Cacheable.cache_adapter.context.dig(key, 'invalidate_time')
+      str_time.nil? ? nil : Time.parse(str_time)
+    end
+
+    # Set the timestamp of the cached data linked to a given API call.
+    # This should be used only to update the cache timestamp of a resource we know is still up-to-date without fetching the resource for real again.
+    #
+    # Parameters::
+    # * *path* (String): API path to contact (from v1/ and without .json)
+    # * *parameters* (Hash<Symbol,Object>): Optional parameters to add to the path [default: {}]
+    # * *verb* (Symbol): Verb to be used (:get, :post...) [default: :get]
+    # * *cache_timestamp* (Time): The cache timestamp to set for this resource
+    def set_api_cache_timestamp(path, cache_timestamp:, parameters: {}, verb: :get)
+      key = ApiClient.cache_key(path, parameters:, verb:)
+      Cacheable.cache_adapter.context[key] = {} unless Cacheable.cache_adapter.context.key?(key)
+      Cacheable.cache_adapter.context[key]['invalidate_time'] = cache_timestamp.utc.strftime('%FT%T.%9NUTC')
+      save_api_cache
+    end
+
     # Send an HTTP request to the API and get back the HTTP response
     #
     # Parameters::
@@ -99,6 +130,18 @@ class NexusMods
       # ApiClient: The API client to be used by the cacheable adapter (singleton pattern)
       attr_accessor :api_client
 
+      # Get the cache key to be used for a given API query
+      #
+      # Parameters::
+      # * *path* (String): API path to contact (from v1/ and without .json)
+      # * *parameters* (Hash<Symbol,Object>): Optional parameters to add to the path [default: {}]
+      # * *verb* (Symbol): Verb to be used (:get, :post...) [default: :get]
+      # Result::
+      # * String: The corresponding cache key
+      def cache_key(path, parameters:, verb:)
+        "#{verb}/#{path}#{parameters.empty? ? '' : "/#{parameters.map { |param, value| "#{param}=#{value}" }.sort.join('/')}"}"
+      end
+
     end
 
     @api_client = nil
@@ -142,9 +185,7 @@ class NexusMods
     cacheable_api(
       :cached_api,
       key_format: proc do |_target, _method_name, method_args, method_kwargs|
-        "#{method_kwargs[:verb]}/#{method_args.first}#{
-          method_kwargs[:parameters].empty? ? '' : "/#{method_kwargs[:parameters].map { |param, value| "#{param}=#{value}" }.sort.join('/')}"
-        }"
+        cache_key(method_args.first, parameters: method_kwargs[:parameters], verb: method_kwargs[:verb])
       end,
       expiry_from_key: proc do |key|
         # Example of keys:

data/lib/nexus_mods/cacheable_with_expiry.rb

@@ -45,7 +45,7 @@ class NexusMods
                     expiry_cache[key].nil? || (Time.now.utc - Time.parse(context['invalidate_time']).utc > expiry_cache[key])
                   end,
                   update_context_after_fetch: proc do |_key, _value, _options, context|
-                    context['invalidate_time'] = Time.now.utc.strftime('%FT%TUTC')
+                    context['invalidate_time'] = Time.now.utc.strftime('%FT%T.%9NUTC')
                   end
                 }
               )

data/lib/nexus_mods/core_extensions/cacheable/cache_adapters/persistent_json_adapter.rb

@@ -13,6 +13,8 @@ module Cacheable
     # * The context information is JSON serializable.
     class PersistentJsonAdapter < MemoryAdapter
 
+      attr_reader :context
+
       # Fetch a key with the givien cache options
       #
       # Parameters::
@@ -87,10 +89,6 @@ module Cacheable
         @context = loaded_content['context']
       end
 
-      private
-
-      attr_reader :context
-
     end
 
   end

data/lib/nexus_mods/version.rb

@@ -1,5 +1,5 @@
 class NexusMods
 
-  VERSION = '2.1.0'
+  VERSION = '2.3.0'
 
 end

data/lib/nexus_mods.rb

@@ -143,6 +143,23 @@ class NexusMods
     end
   end
 
+  # Get the cached timestamp of the list of games
+  #
+  # Result::
+  # * Time or nil: Freshness time of the data in the API cache, or nil if not present in the cache
+  def games_cache_timestamp
+    @api_client.api_cache_timestamp('games')
+  end
+
+  # Set the cached timestamp of the list of games.
+  # This should be used only to update the cache timestamp of a resource we know is still up-to-date without fetching the resource for real again.
+  #
+  # Parameters::
+  # * *cache_timestamp* (Time): The cache timestamp to set for this resource
+  def set_games_cache_timestamp(cache_timestamp:)
+    @api_client.set_api_cache_timestamp('games', cache_timestamp:)
+  end
+
   # Get information about a mod
   #
   # Parameters::
@@ -183,6 +200,28 @@ class NexusMods
     )
   end
 
+  # Get the cached timestamp of a mod information
+  #
+  # Parameters::
+  # * *game_domain_name* (String): Game domain name to query by default [default: @game_domain_name]
+  # * *mod_id* (Integer): The mod ID [default: @mod_id]
+  # Result::
+  # * Time or nil: Freshness time of the data in the API cache, or nil if not present in the cache
+  def mod_cache_timestamp(game_domain_name: @game_domain_name, mod_id: @mod_id)
+    @api_client.api_cache_timestamp("games/#{game_domain_name}/mods/#{mod_id}")
+  end
+
+  # Set the cached timestamp of a mod information.
+  # This should be used only to update the cache timestamp of a resource we know is still up-to-date without fetching the resource for real again.
+  #
+  # Parameters::
+  # * *game_domain_name* (String): Game domain name to query by default [default: @game_domain_name]
+  # * *mod_id* (Integer): The mod ID [default: @mod_id]
+  # * *cache_timestamp* (Time): The cache timestamp to set for this resource
+  def set_mod_cache_timestamp(cache_timestamp:, game_domain_name: @game_domain_name, mod_id: @mod_id)
+    @api_client.set_api_cache_timestamp("games/#{game_domain_name}/mods/#{mod_id}", cache_timestamp:)
+  end
+
   # Get files belonging to a mod
   #
   # Parameters::
@@ -214,6 +253,28 @@ class NexusMods
     end
   end
 
+  # Get the cached timestamp of a mod files information
+  #
+  # Parameters::
+  # * *game_domain_name* (String): Game domain name to query by default [default: @game_domain_name]
+  # * *mod_id* (Integer): The mod ID [default: @mod_id]
+  # Result::
+  # * Time or nil: Freshness time of the data in the API cache, or nil if not present in the cache
+  def mod_files_cache_timestamp(game_domain_name: @game_domain_name, mod_id: @mod_id)
+    @api_client.api_cache_timestamp("games/#{game_domain_name}/mods/#{mod_id}/files")
+  end
+
+  # Set the cached timestamp of a mod files information.
+  # This should be used only to update the cache timestamp of a resource we know is still up-to-date without fetching the resource for real again.
+  #
+  # Parameters::
+  # * *game_domain_name* (String): Game domain name to query by default [default: @game_domain_name]
+  # * *mod_id* (Integer): The mod ID [default: @mod_id]
+  # * *cache_timestamp* (Time): The cache timestamp to set for this resource
+  def set_mod_files_cache_timestamp(cache_timestamp:, game_domain_name: @game_domain_name, mod_id: @mod_id)
+    @api_client.set_api_cache_timestamp("games/#{game_domain_name}/mods/#{mod_id}/files", cache_timestamp:)
+  end
+
   # Get a list of updated mod ids since a given time
   #
   # Parameters::
@@ -227,6 +288,58 @@ class NexusMods
   # Result::
   # * Array<ModUpdates>: Mod's updates information
   def updated_mods(game_domain_name: @game_domain_name, since: :one_day, clear_cache: false)
+    @api_client.api("games/#{game_domain_name}/mods/updated", parameters: period_to_url_params(since), clear_cache:).map do |updated_mod_json|
+      Api::ModUpdates.new(
+        mod_id: updated_mod_json['mod_id'],
+        latest_file_update: Time.at(updated_mod_json['latest_file_update']).utc,
+        latest_mod_activity: Time.at(updated_mod_json['latest_mod_activity']).utc
+      )
+    end
+  end
+
+  # Get the cached timestamp of updated mod ids
+  #
+  # Parameters::
+  # * *game_domain_name* (String): Game domain name to query by default [default: @game_domain_name]
+  # * *since* (Symbol): The time from which we look for updated mods [default: :one_day]
+  #   Possible values are:
+  #   * *one_day*: Since 1 day
+  #   * *one_week*: Since 1 week
+  #   * *one_month*: Since 1 month
+  # Result::
+  # * Time or nil: Freshness time of the data in the API cache, or nil if not present in the cache
+  def updated_mods_cache_timestamp(game_domain_name: @game_domain_name, since: :one_day)
+    @api_client.api_cache_timestamp("games/#{game_domain_name}/mods/updated", parameters: period_to_url_params(since))
+  end
+
+  # Set the cached timestamp of updated mod ids.
+  # This should be used only to update the cache timestamp of a resource we know is still up-to-date without fetching the resource for real again.
+  #
+  # Parameters::
+  # * *game_domain_name* (String): Game domain name to query by default [default: @game_domain_name]
+  # * *since* (Symbol): The time from which we look for updated mods [default: :one_day]
+  #   Possible values are:
+  #   * *one_day*: Since 1 day
+  #   * *one_week*: Since 1 week
+  #   * *one_month*: Since 1 month
+  # * *cache_timestamp* (Time): The cache timestamp to set for this resource
+  def set_updated_mods_cache_timestamp(cache_timestamp:, game_domain_name: @game_domain_name, since: :one_day)
+    @api_client.set_api_cache_timestamp("games/#{game_domain_name}/mods/updated", parameters: period_to_url_params(since), cache_timestamp:)
+  end
+
+  private
+
+  # Get the URL parameters from the required period
+  #
+  # Parameters::
+  # * *since* (Symbol): The time from which we look for updated mods
+  #   Possible values are:
+  #   * *one_day*: Since 1 day
+  #   * *one_week*: Since 1 week
+  #   * *one_month*: Since 1 month
+  # Result::
+  # * Hash<Symbol,Object>: Corresponding URL parameters
+  def period_to_url_params(since)
     nexus_mods_period = {
       one_day: '1d',
       one_week: '1w',
@@ -234,13 +347,7 @@ class NexusMods
     }[since]
     raise "Unknown time stamp: #{since}" if nexus_mods_period.nil?
 
-    @api_client.api("games/#{game_domain_name}/mods/updated", parameters: { period: nexus_mods_period }, clear_cache:).map do |updated_mod_json|
-      Api::ModUpdates.new(
-        mod_id: updated_mod_json['mod_id'],
-        latest_file_update: Time.at(updated_mod_json['latest_file_update']).utc,
-        latest_mod_activity: Time.at(updated_mod_json['latest_mod_activity']).utc
-      )
-    end
+    { period: nexus_mods_period }
   end
 
 end

data/spec/nexus_mods_test/factories/games.rb

@@ -5,7 +5,7 @@ module NexusModsTest
     module Games
 
       # Test game with id 100
-      def json_game100
+      def self.json_game100
         {
           'id' => 100,
           'name' => 'Morrowind',
@@ -35,8 +35,12 @@ module NexusModsTest
         }
       end
 
+      def json_game100
+        Games.json_game100
+      end
+
       # Test game with id 101
-      def json_game101
+      def self.json_game101
         {
           'id' => 101,
           'name' => 'Oblivion',
@@ -66,6 +70,10 @@ module NexusModsTest
         }
       end
 
+      def json_game101
+        Games.json_game101
+      end
+
       # Expect a game to be the test game of id 100
       #
       # Parameters::

data/spec/nexus_mods_test/factories/mod_files.rb

@@ -5,7 +5,7 @@ module NexusModsTest
     module ModFiles
 
       # Test mod file with id 2472
-      def json_mod_file2472
+      def self.json_mod_file2472
         {
           'id' => [
             2472,
@@ -32,8 +32,12 @@ module NexusModsTest
         }
       end
 
+      def json_mod_file2472
+        ModFiles.json_mod_file2472
+      end
+
       # Test mod file with id 2487
-      def json_mod_file2487
+      def self.json_mod_file2487
         {
           'id' => [
             2487,
@@ -60,6 +64,10 @@ module NexusModsTest
         }
       end
 
+      def json_mod_file2487
+        ModFiles.json_mod_file2487
+      end
+
       # Expect a mod's file to be the example one with id 2472
       #
       # Parameters::

data/spec/nexus_mods_test/factories/mod_updates.rb

@@ -5,7 +5,7 @@ module NexusModsTest
     module ModUpdates
 
       # Test mod updates with id 2014
-      def json_mod_updates2014
+      def self.json_mod_updates2014
         {
           'mod_id' => 2014,
           'latest_file_update' => 1_655_813_855,
@@ -13,8 +13,12 @@ module NexusModsTest
         }
       end
 
+      def json_mod_updates2014
+        ModUpdates.json_mod_updates2014
+      end
+
       # Test mod updates with id 100
-      def json_mod_updates100
+      def self.json_mod_updates100
         {
           'mod_id' => 100,
           'latest_file_update' => 1_681_143_964,
@@ -22,6 +26,10 @@ module NexusModsTest
         }
       end
 
+      def json_mod_updates100
+        ModUpdates.json_mod_updates100
+      end
+
       # Expect a mod's updates to be the example one with id 2014
       #
       # Parameters::

data/spec/nexus_mods_test/factories/mods.rb

@@ -5,7 +5,7 @@ module NexusModsTest
     module Mods
 
       # Example of JSON object returned by the API for a mod information, having all possible fields
-      def json_complete_mod
+      def self.json_complete_mod
         {
           'name' => 'ApachiiSkyHair SSE',
           'summary' => 'New Female and Male Hairstyles for Humans, Elves and Orcs. Converted hair from Sims2 and Sims3.<br />Standalone version.',
@@ -44,8 +44,12 @@ module NexusModsTest
         }
       end
 
+      def json_complete_mod
+        Mods.json_complete_mod
+      end
+
       # Example of JSON object returned by the API for a mod information, having minimum fields
-      def json_partial_mod
+      def self.json_partial_mod
         {
           'mod_downloads' => 13_634_545,
           'mod_unique_downloads' => 4_052_221,
@@ -75,6 +79,10 @@ module NexusModsTest
         }
       end
 
+      def json_partial_mod
+        Mods.json_partial_mod
+      end
+
       # Expect a mod to be the example complete one
       #
       # Parameters::

data/spec/nexus_mods_test/scenarios/nexus_mods/nexus_mods_caching_spec.rb

@@ -10,163 +10,291 @@ describe NexusMods do
       nexus_mods.api_limits
     end
 
-    it 'caches games queries' do
-      expect_validate_user
-      expect_http_call_to(
-        path: '/v1/games.json',
-        json: [
-          json_game100,
-          json_game101
+    {
+      'games' => {
+        expected_api_path: '/v1/games.json',
+        mocked_api_json: [
+          NexusModsTest::Factories::Games.json_game100,
+          NexusModsTest::Factories::Games.json_game101
+        ],
+        query: proc { |nm| nm.games },
+        query_without_cache: proc { |nm| nm.games(clear_cache: true) },
+        get_cache_timestamp: proc { |nm| nm.games_cache_timestamp },
+        set_cache_timestamp: proc { |nm, ts| nm.set_games_cache_timestamp(cache_timestamp: ts) },
+        expiry_cache_param: :games
+      },
+      'mods' => {
+        expected_api_path: '/v1/games/skyrimspecialedition/mods/2014.json',
+        mocked_api_json: NexusModsTest::Factories::Mods.json_complete_mod,
+        query: proc { |nm| nm.mod(game_domain_name: 'skyrimspecialedition', mod_id: 2014) },
+        query_without_cache: proc { |nm| nm.mod(game_domain_name: 'skyrimspecialedition', mod_id: 2014, clear_cache: true) },
+        get_cache_timestamp: proc { |nm| nm.mod_cache_timestamp(game_domain_name: 'skyrimspecialedition', mod_id: 2014) },
+        set_cache_timestamp: proc { |nm, ts| nm.set_mod_cache_timestamp(game_domain_name: 'skyrimspecialedition', mod_id: 2014, cache_timestamp: ts) },
+        expiry_cache_param: :mod
+      },
+      'mod files' => {
+        expected_api_path: '/v1/games/skyrimspecialedition/mods/2014/files.json',
+        mocked_api_json: {
+          files: [
+            NexusModsTest::Factories::ModFiles.json_mod_file2472,
+            NexusModsTest::Factories::ModFiles.json_mod_file2487
+          ]
+        },
+        query: proc { |nm| nm.mod_files(game_domain_name: 'skyrimspecialedition', mod_id: 2014) },
+        query_without_cache: proc { |nm| nm.mod_files(game_domain_name: 'skyrimspecialedition', mod_id: 2014, clear_cache: true) },
+        get_cache_timestamp: proc { |nm| nm.mod_files_cache_timestamp(game_domain_name: 'skyrimspecialedition', mod_id: 2014) },
+        set_cache_timestamp: proc { |nm, ts| nm.set_mod_files_cache_timestamp(game_domain_name: 'skyrimspecialedition', mod_id: 2014, cache_timestamp: ts) },
+        expiry_cache_param: :mod_files
+      }
+    }.merge(
+      {
+        'last day' => {
+          since: :one_day,
+          expected_url_params: 'period=1d'
+        },
+        'last week' => {
+          since: :one_week,
+          expected_url_params: 'period=1w'
+        },
+        'last month' => {
+          since: :one_month,
+          expected_url_params: 'period=1m'
+        }
+      }.to_h do |since, since_config|
+        [
+          "mod updates since #{since}",
+          {
+            expected_api_path: "/v1/games/skyrimspecialedition/mods/updated.json?#{since_config[:expected_url_params]}",
+            mocked_api_json: [
+              NexusModsTest::Factories::ModUpdates.json_mod_updates2014,
+              NexusModsTest::Factories::ModUpdates.json_mod_updates100
+            ],
+            query: proc { |nm| nm.updated_mods(game_domain_name: 'skyrimspecialedition', since: since_config[:since]) },
+            query_without_cache: proc { |nm| nm.updated_mods(game_domain_name: 'skyrimspecialedition', since: since_config[:since], clear_cache: true) },
+            get_cache_timestamp: proc { |nm| nm.updated_mods_cache_timestamp(game_domain_name: 'skyrimspecialedition', since: since_config[:since]) },
+            set_cache_timestamp: proc { |nm, ts| nm.set_updated_mods_cache_timestamp(game_domain_name: 'skyrimspecialedition', since: since_config[:since], cache_timestamp: ts) }
+          }
         ]
-      )
-      games = nexus_mods.games
-      expect(nexus_mods.games).to eq games
-    end
+      end
+    ).each do |resource, resource_config|
 
-    it 'does not cache games queries if asked' do
-      expect_validate_user
-      expect_http_call_to(
-        path: '/v1/games.json',
-        json: [
-          json_game100,
-          json_game101
-        ],
-        times: 2
-      )
-      games = nexus_mods.games
-      expect(nexus_mods.games(clear_cache: true)).to eq games
-    end
+      context "when testing #{resource}" do
 
-    it 'caches mod queries' do
-      expect_validate_user
-      expect_http_call_to(
-        path: '/v1/games/skyrimspecialedition/mods/2014.json',
-        json: json_complete_mod
-      )
-      mod = nexus_mods.mod(game_domain_name: 'skyrimspecialedition', mod_id: 2014)
-      expect(nexus_mods.mod(game_domain_name: 'skyrimspecialedition', mod_id: 2014)).to eq mod
-    end
+        it 'caches API queries' do
+          expect_validate_user
+          expect_http_call_to(
+            path: resource_config[:expected_api_path],
+            json: resource_config[:mocked_api_json]
+          )
+          resource = resource_config[:query].call(nexus_mods)
+          expect(resource_config[:query].call(nexus_mods)).to eq resource
+        end
 
-    it 'does not cache mod queries if asked' do
-      expect_validate_user
-      expect_http_call_to(
-        path: '/v1/games/skyrimspecialedition/mods/2014.json',
-        json: json_complete_mod,
-        times: 2
-      )
-      mod = nexus_mods.mod(game_domain_name: 'skyrimspecialedition', mod_id: 2014)
-      expect(nexus_mods.mod(game_domain_name: 'skyrimspecialedition', mod_id: 2014, clear_cache: true)).to eq mod
-    end
+        it 'does not cache API queries if asked' do
+          expect_validate_user
+          expect_http_call_to(
+            path: resource_config[:expected_api_path],
+            json: resource_config[:mocked_api_json],
+            times: 2
+          )
+          resource = resource_config[:query].call(nexus_mods)
+          expect(resource_config[:query_without_cache].call(nexus_mods)).to eq resource
+        end
 
-    it 'caches mod files queries' do
-      expect_validate_user
-      expect_http_call_to(
-        path: '/v1/games/skyrimspecialedition/mods/2014/files.json',
-        json: { files: [json_mod_file2472, json_mod_file2487] }
-      )
-      mod_files = nexus_mods.mod_files(game_domain_name: 'skyrimspecialedition', mod_id: 2014)
-      expect(nexus_mods.mod_files(game_domain_name: 'skyrimspecialedition', mod_id: 2014)).to eq mod_files
-    end
+        if resource_config[:expiry_cache_param]
 
-    it 'does not cache mod files queries if asked' do
-      expect_validate_user
-      expect_http_call_to(
-        path: '/v1/games/skyrimspecialedition/mods/2014/files.json',
-        json: { files: [json_mod_file2472, json_mod_file2487] },
-        times: 2
-      )
-      mod_files = nexus_mods.mod_files(game_domain_name: 'skyrimspecialedition', mod_id: 2014)
-      expect(nexus_mods.mod_files(game_domain_name: 'skyrimspecialedition', mod_id: 2014, clear_cache: true)).to eq mod_files
-    end
+          it 'expires API queries cache' do
+            expect_validate_user
+            expect_http_call_to(
+              path: resource_config[:expected_api_path],
+              json: resource_config[:mocked_api_json],
+              times: 2
+            )
+            nexus_mods_instance = nexus_mods(api_cache_expiry: { resource_config[:expiry_cache_param] => 1 })
+            resource = resource_config[:query].call(nexus_mods_instance)
+            sleep 2
+            expect(resource_config[:query].call(nexus_mods_instance)).to eq resource
+          end
 
-    {
-      'last day' => {
-        since: :one_day,
-        expected_url_params: 'period=1d'
-      },
-      'last week' => {
-        since: :one_week,
-        expected_url_params: 'period=1w'
-      },
-      'last month' => {
-        since: :one_month,
-        expected_url_params: 'period=1m'
-      }
-    }.each do |since, since_config|
+        end
 
-      context "when testing updated months since #{since}" do
+        it 'stores no timestamp of the data stored in the API cache before fetching data' do
+          expect_validate_user
+          expect(resource_config[:get_cache_timestamp].call(nexus_mods)).to be_nil
+        end
 
-        it 'caches mod updates queries' do
+        it 'retrieves the timestamp of the data stored in the API cache' do
           expect_validate_user
           expect_http_call_to(
-            path: "/v1/games/skyrimspecialedition/mods/updated.json?#{since_config[:expected_url_params]}",
-            json: [
-              json_mod_updates2014,
-              json_mod_updates100
-            ]
+            path: resource_config[:expected_api_path],
+            json: resource_config[:mocked_api_json]
           )
-          mod_updates = nexus_mods.updated_mods(game_domain_name: 'skyrimspecialedition', since: since_config[:since])
-          expect(nexus_mods.updated_mods(game_domain_name: 'skyrimspecialedition', since: since_config[:since])).to eq mod_updates
+          before = Time.now
+          resource_config[:query].call(nexus_mods)
+          after = Time.now
+          expect(resource_config[:get_cache_timestamp].call(nexus_mods)).to be_between(before, after)
         end
 
-        it 'does not cache mod updates queries if asked' do
+        it 'changes manually the timestamp of the data stored in the API cache' do
           expect_validate_user
           expect_http_call_to(
-            path: "/v1/games/skyrimspecialedition/mods/updated.json?#{since_config[:expected_url_params]}",
-            json: [
-              json_mod_updates2014,
-              json_mod_updates100
-            ],
+            path: resource_config[:expected_api_path],
+            json: resource_config[:mocked_api_json]
+          )
+          resource_config[:query].call(nexus_mods)
+          new_cache_timestamp = Time.parse('2023-01-12 11:22:33 UTC')
+          resource_config[:set_cache_timestamp].call(nexus_mods, new_cache_timestamp)
+          expect(resource_config[:get_cache_timestamp].call(nexus_mods)).to eq new_cache_timestamp
+        end
+
+        it 'retrieves the timestamp of the games data stored in the cache even after cache is used' do
+          expect_validate_user
+          expect_http_call_to(
+            path: resource_config[:expected_api_path],
+            json: resource_config[:mocked_api_json]
+          )
+          before = Time.now
+          resource_config[:query].call(nexus_mods)
+          after = Time.now
+          resource_config[:query].call(nexus_mods)
+          expect(resource_config[:get_cache_timestamp].call(nexus_mods)).to be_between(before, after)
+        end
+
+        it 'retrieves the timestamp of the games data stored in the cache even after cache is persisted' do
+          with_api_cache_file do |api_cache_file|
+            expect_validate_user(times: 2)
+            expect_http_call_to(
+              path: resource_config[:expected_api_path],
+              json: resource_config[:mocked_api_json]
+            )
+            before = Time.now
+            resource_config[:query].call(nexus_mods(api_cache_file:))
+            after = Time.now
+            reset_nexus_mods
+            expect(resource_config[:get_cache_timestamp].call(nexus_mods(api_cache_file:))).to be_between(before, after)
+          end
+        end
+
+        it 'persists the cache timestamp that has been changed manually' do
+          with_api_cache_file do |api_cache_file|
+            expect_validate_user(times: 2)
+            expect_http_call_to(
+              path: resource_config[:expected_api_path],
+              json: resource_config[:mocked_api_json]
+            )
+            resource_config[:query].call(nexus_mods(api_cache_file:))
+            new_cache_timestamp = Time.parse('2023-01-12 11:22:33 UTC')
+            resource_config[:set_cache_timestamp].call(nexus_mods, new_cache_timestamp)
+            reset_nexus_mods
+            expect(resource_config[:get_cache_timestamp].call(nexus_mods(api_cache_file:))).to eq new_cache_timestamp
+          end
+        end
+
+        it 'updates the timestamp of the data stored in the API cache by forcing an API query' do
+          expect_validate_user
+          expect_http_call_to(
+            path: resource_config[:expected_api_path],
+            json: resource_config[:mocked_api_json],
             times: 2
           )
-          mod_updates = nexus_mods.updated_mods(game_domain_name: 'skyrimspecialedition', since: since_config[:since])
-          expect(nexus_mods.updated_mods(game_domain_name: 'skyrimspecialedition', since: since_config[:since], clear_cache: true)).to eq mod_updates
+          resource_config[:query].call(nexus_mods)
+          sleep 1
+          before = Time.now
+          resource_config[:query_without_cache].call(nexus_mods)
+          after = Time.now
+          expect(resource_config[:get_cache_timestamp].call(nexus_mods)).to be_between(before, after)
         end
 
-      end
+        it 'updates the timestamp of the data stored in the API cache by updating manually the cache timestamp' do
+          expect_validate_user
+          expect_http_call_to(
+            path: resource_config[:expected_api_path],
+            json: resource_config[:mocked_api_json],
+            times: 2
+          )
+          resource_config[:query].call(nexus_mods)
+          resource_config[:set_cache_timestamp].call(nexus_mods, Time.now.utc - (365 * 24 * 60 * 60))
+          before = Time.now
+          resource_config[:query].call(nexus_mods)
+          after = Time.now
+          expect(resource_config[:get_cache_timestamp].call(nexus_mods)).to be_between(before, after)
+        end
 
-    end
+        context 'when testing cache persistence in files' do
 
-    it 'expires games queries cache' do
-      expect_validate_user
-      expect_http_call_to(
-        path: '/v1/games.json',
-        json: [
-          json_game100,
-          json_game101
-        ],
-        times: 2
-      )
-      nexus_mods_instance = nexus_mods(api_cache_expiry: { games: 1 })
-      games = nexus_mods_instance.games
-      sleep 2
-      expect(nexus_mods_instance.games).to eq games
-    end
+          it 'persists API cache in a file' do
+            with_api_cache_file do |api_cache_file|
+              expect_validate_user
+              expect_http_call_to(
+                path: resource_config[:expected_api_path],
+                json: resource_config[:mocked_api_json]
+              )
+              resource_config[:query].call(nexus_mods(api_cache_file:))
+              expect(File.exist?(api_cache_file)).to be true
+              expect(File.size(api_cache_file)).to be > 0
+            end
+          end
 
-    it 'expires mod queries cache' do
-      expect_validate_user
-      expect_http_call_to(
-        path: '/v1/games/skyrimspecialedition/mods/2014.json',
-        json: json_complete_mod,
-        times: 2
-      )
-      nexus_mods_instance = nexus_mods(api_cache_expiry: { mod: 1 })
-      mod = nexus_mods_instance.mod(game_domain_name: 'skyrimspecialedition', mod_id: 2014)
-      sleep 2
-      expect(nexus_mods_instance.mod(game_domain_name: 'skyrimspecialedition', mod_id: 2014)).to eq mod
-    end
+          it 'uses API cache from a file' do
+            with_api_cache_file do |api_cache_file|
+              expect_validate_user(times: 2)
+              expect_http_call_to(
+                path: resource_config[:expected_api_path],
+                json: resource_config[:mocked_api_json]
+              )
+              # Generate the cache first
+              resource = resource_config[:query].call(nexus_mods(api_cache_file:))
+              # Force a new instance of NexusMods API to run
+              reset_nexus_mods
+              expect(resource_config[:query].call(nexus_mods(api_cache_file:))).to eq resource
+            end
+          end
+
+          if resource_config[:expiry_cache_param]
+
+            it 'uses API cache from a file, taking expiry time into account' do
+              with_api_cache_file do |api_cache_file|
+                expect_validate_user(times: 2)
+                expect_http_call_to(
+                  path: resource_config[:expected_api_path],
+                  json: resource_config[:mocked_api_json],
+                  times: 2
+                )
+                # Generate the cache first
+                resource = resource_config[:query].call(nexus_mods(api_cache_file:, api_cache_expiry: { resource_config[:expiry_cache_param] => 1 }))
+                # Force a new instance of NexusMods API to run
+                reset_nexus_mods
+                sleep 2
+                # As the expiry time is 1 second, then the cache should still be invalidated
+                expect(resource_config[:query].call(nexus_mods(api_cache_file:, api_cache_expiry: { resource_config[:expiry_cache_param] => 1 }))).to eq resource
+              end
+            end
+
+            it 'uses API cache from a file, taking expiry time of the new process into account' do
+              with_api_cache_file do |api_cache_file|
+                expect_validate_user(times: 2)
+                expect_http_call_to(
+                  path: resource_config[:expected_api_path],
+                  json: resource_config[:mocked_api_json],
+                  times: 2
+                )
+                # Generate the cache first
+                resource = resource_config[:query].call(nexus_mods(api_cache_file:, api_cache_expiry: { resource_config[:expiry_cache_param] => 10 }))
+                # Force a new instance of NexusMods API to run
+                reset_nexus_mods
+                sleep 2
+                # Even if the expiry time was 10 seconds while fetching the resource,
+                # if we decide it has to be 1 second now then it has to be invalidated.
+                expect(resource_config[:query].call(nexus_mods(api_cache_file:, api_cache_expiry: { resource_config[:expiry_cache_param] => 1 }))).to eq resource
+              end
+            end
+
+          end
+
+        end
+
+      end
 
-    it 'expires mod files queries cache' do
-      expect_validate_user
-      expect_http_call_to(
-        path: '/v1/games/skyrimspecialedition/mods/2014/files.json',
-        json: { files: [json_mod_file2472, json_mod_file2487] },
-        times: 2
-      )
-      nexus_mods_instance = nexus_mods(api_cache_expiry: { mod_files: 1 })
-      mod_files = nexus_mods_instance.mod_files(game_domain_name: 'skyrimspecialedition', mod_id: 2014)
-      sleep 2
-      expect(nexus_mods_instance.mod_files(game_domain_name: 'skyrimspecialedition', mod_id: 2014)).to eq mod_files
     end
 
     it 'only clears the cache of the wanted resource' do
@@ -190,83 +318,6 @@ describe NexusMods do
 
     context 'with file persistence' do
 
-      it 'persists API cache in a file' do
-        with_api_cache_file do |api_cache_file|
-          expect_validate_user
-          expect_http_call_to(
-            path: '/v1/games.json',
-            json: [
-              json_game100,
-              json_game101
-            ]
-          )
-          nexus_mods(api_cache_file:).games
-          expect(File.exist?(api_cache_file)).to be true
-          expect(File.size(api_cache_file)).to be > 0
-        end
-      end
-
-      it 'uses API cache from a file' do
-        with_api_cache_file do |api_cache_file|
-          expect_validate_user(times: 2)
-          expect_http_call_to(
-            path: '/v1/games.json',
-            json: [
-              json_game100,
-              json_game101
-            ]
-          )
-          # Generate the cache first
-          games = nexus_mods(api_cache_file:).games
-          # Force a new instance of NexusMods API to run
-          reset_nexus_mods
-          expect(nexus_mods(api_cache_file:).games).to eq games
-        end
-      end
-
-      it 'uses API cache from a file, taking expiry time into account' do
-        with_api_cache_file do |api_cache_file|
-          expect_validate_user(times: 2)
-          expect_http_call_to(
-            path: '/v1/games.json',
-            json: [
-              json_game100,
-              json_game101
-            ],
-            times: 2
-          )
-          # Generate the cache first
-          games = nexus_mods(api_cache_file:, api_cache_expiry: { games: 1 }).games
-          # Force a new instance of NexusMods API to run
-          reset_nexus_mods
-          sleep 2
-          # As the expiry time is 1 second, then the cache should still be invalidated
-          expect(nexus_mods(api_cache_file:, api_cache_expiry: { games: 1 }).games).to eq games
-        end
-      end
-
-      it 'uses API cache from a file, taking expiry time of the new process into account' do
-        with_api_cache_file do |api_cache_file|
-          expect_validate_user(times: 2)
-          expect_http_call_to(
-            path: '/v1/games.json',
-            json: [
-              json_game100,
-              json_game101
-            ],
-            times: 2
-          )
-          # Generate the cache first
-          games = nexus_mods(api_cache_file:, api_cache_expiry: { games: 10 }).games
-          # Force a new instance of NexusMods API to run
-          reset_nexus_mods
-          sleep 2
-          # Even if the expiry time was 10 seconds while fetching the resource,
-          # if we decide it has to be 1 second now then it has to be invalidated.
-          expect(nexus_mods(api_cache_file:, api_cache_expiry: { games: 1 }).games).to eq games
-        end
-      end
-
       it 'completes the API cache from a file' do
         with_api_cache_file do |api_cache_file|
           expect_validate_user(times: 3)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nexus_mods
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Muriel Salvan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-11 00:00:00.000000000 Z
+date: 2023-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday