microslop_one_drive 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bf99630f0f09cb4d635d7881c2db5b0d53af498f33b32724b1522d10cd464985
+  data.tar.gz: a5111efbd38ae81fe7d06524461bade0fe49761a82dccad1747f09c8ae0c751b
+SHA512:
+  metadata.gz: 2d683dcebe786a18941e751f0e8f9fa5962d266e9eb69e1ceadcafa1c710a563de06b3ee7153ef4cf0350658c0b735bb55e1ea45a5f6071212c66339696514c5
+  data.tar.gz: a2141155fc90fdc9c07bb7b725ee43d130d0e8e4e320193840a013621b0c1d0b6b901d5cd1d9df72e2635aab33514760473a39ab246630c52654ee56a5f82c97

data/LICENSE.txt

@@ -0,0 +1 @@
+Proprietary for now

data/README.md

@@ -0,0 +1,160 @@
+# MicroslopOneDrive
+
+Microslop OneDrive API client.
+
+See <https://learn.microsoft.com/en-us/onedrive/developer/rest-api/>
+
+Graph explorer (API sandbox): <https://developer.microsoft.com/en-us/graph/graph-explorer>
+
+## Installation
+
+```rb
+TODO: DOCUMENT
+```
+
+## Usage
+
+### Create a client
+
+```rb
+access_token = "..." # Get an access token via OAuth 2.0
+
+client = MicroslopOneDrive::Client.new(access_token)
+```
+
+### Get the current user
+
+```rb
+me = client.me
+me.class # => MicroslopOneDrive::User
+me.email_address # => person@example.com
+me.display_name # => Example Person
+```
+
+### Get a list of the user's Drives
+
+```rb
+drive_list = client.drives
+
+drive_list.class # => MicroslopOneDrive::DriveList
+drive_list.next_page? # => false
+drive_list.drives # => [MicroslopOneDrive::Drive, ...]
+
+drive = drive_list.drives.first
+drive.class # => MicroslopOneDrive::Drive
+drive.id # => "0f0**********42"
+drive.name # => "OneDrive"
+drive.url # => "https://my.microsoftpersonalcontent.com/..."
+drive.drive_type # => "personal"
+```
+
+### Get a single Drive
+
+```rb
+drive = client.drive(drive_id: "0f097********a42")
+
+drive.class # => MicroslopOneDrive::Drive
+drive.id # => "0f097********a42"
+drive.name # => "OneDrive"
+drive.url # => "https://my.microsoftpersonalcontent.com/personal/..."
+drive.drive_type # => "personal"
+```
+
+### Get a delta of changes to a Drive
+
+```rb
+# Initial delta (all current items + token for later)
+drive_item_list = client.delta(drive_id: "0f097********a42")
+
+drive_item_list.class # => MicroslopOneDrive::DriveItemList
+drive_item_list.items # => [MicroslopOneDrive::DriveItem, ...]
+
+drive_item_list.next_page? # => true if more pages
+drive_item_list.next_token # => use with delta(drive_id:, token:) for next page
+drive_item_list.delta_link # => URL for incremental sync (when no next_page?)
+drive_item_list.delta_token # => use with delta(drive_id:, token:) for incremental sync
+
+# Next page (if next_page? was true)
+client.delta(drive_id: "0f097********a42", token: drive_item_list.next_token)
+
+# Incremental sync (only changes since last delta)
+client.delta(drive_id: "0f097********a42", token: saved_delta_token)
+```
+
+Delta items have parent/child set: `item.parent`, `item.children`, and `item.path` (e.g. `"root:/folder/subfolder/file.txt"`).
+
+### Get a DriveItem (file or folder)
+
+```rb
+item = client.drive_item(item_id: "F0**********42!sa466********************1479272d27")
+
+item.class # => MicroslopOneDrive::DriveItem
+item.name # => "Getting started with OneDrive.pdf"
+item.identifier # => "F0**********42!sa466********************1479272d27"
+item.url # => "https://onedrive.live.com?cid=..."
+item.file? # => true
+item.folder? # => false
+item.mime_type # => "application/pdf"
+item.size # => 1053417
+item.created_at # => 2026-02-19 07:35:52 UTC
+item.updated_at # => 2026-02-19 07:35:52 UTC
+item.parent_identifier # => "F0**********42!sea8cc6b********************5c639"
+item.deleted? # => false
+item.shared? # => true if the item has sharing info
+item.path # => "root:/Documents/Getting started with OneDrive.pdf" (from delta only; nil for single item)
+item.is_root? # => true for root folder
+```
+
+### Check if a DriveItem exists
+
+```rb
+client.item_exists?(item_id: "F0**********42!sa466********************1479272d27") # => true
+client.item_exists?(item_id: "F0**********42!not-an-item-id") # => false
+```
+
+### Get permissions for a DriveItem
+
+```rb
+permission_list = client.permissions(item_id: "F0**********42!sa466********************1479272d27")
+permission_list.class # => MicroslopOneDrive::PermissionList
+permission_list.permissions # => [MicroslopOneDrive::Permission, ...]
+
+permission = permission_list.permissions.first
+permission.role # => "write" or "owner" etc.
+permission.audience.type # => "user" or "anyone"
+permission.audience.identifier # => email for user, "anyone_with_the_link" for link
+permission.audience.display_name # => "Amy Smith"
+permission.audience.email_address # => "amy@example.com" (nil for "anyone with the link")
+```
+
+Returns an empty permission list if the item does not exist (404).
+
+## Contributing
+
+### Setup
+
+```sh
+mise init
+bundle install
+```
+
+### Running tests
+
+```sh
+bundle exec rake test
+```
+
+## Building and publishing
+
+```sh
+# Signin if not already:
+gem signin
+
+# Bump version in lib/microslop_one_drive/version.rb
+
+# Then build:
+gem build microslop_drive.gemspec
+
+
+gem push microslop_one_drive-0.1.0.gem
+```

data/lib/microslop_one_drive/audience.rb

@@ -0,0 +1,32 @@
+module MicroslopOneDrive
+  class Audience
+    attr_reader :type, :identifier, :display_name, :email_address
+
+    def initialize(type:, identifier:, display_name:, email_address: nil)
+      @type = type
+      @identifier = identifier
+      @display_name = display_name
+      @email_address = email_address
+    end
+
+    # Converts a "siteUser" object into an OneDriveAudience object.
+    #
+    # A siteUser object looks like this:
+    #
+    # {
+    #   "displayName" => "Bob Bentley",
+    #   "email" => "bob@haikucode.dev",
+    #   "id" => "12",
+    #   "loginName" => "i:0#.f|membership|bob@haikucode.dev"
+    # }
+    #
+    def self.from_site_user(site_user)
+      new(
+        type: "user",
+        identifier: site_user.fetch("email"),
+        display_name: site_user.fetch("displayName"),
+        email_address: site_user.fetch("email")
+      )
+    end
+  end
+end

data/lib/microslop_one_drive/client.rb

@@ -0,0 +1,113 @@
+module MicroslopOneDrive
+  class Client
+    BASE_URL = "https://graph.microsoft.com/v1.0".freeze
+
+    def initialize(access_token)
+      @access_token = access_token
+
+      @headers = {
+        "Authorization" => "Bearer #{@access_token}",
+        "Content-Type" => "application/json",
+        "Prefer" => "hierarchicalsharing"
+      }
+    end
+
+    # Gets the current user
+    #
+    # @return [MicroslopOneDrive::User]
+    def me
+      response = get(path: "me", query: {})
+      handle_error(response) unless response.success?
+      MicroslopOneDrive::User.new(response.parsed_response)
+    end
+
+    # Gets all Drives the current user has access to.
+    #
+    # NOTE: This will include some internal Microsoft drives that aren't real drives, such as AI, Face scans, and other
+    # shitty things.
+    #
+    # @return [MicroslopOneDrive::DriveList]
+    def drives
+      response = get(path: "me/drives", query: {})
+      handle_error(response) unless response.success?
+      MicroslopOneDrive::DriveList.new(response.parsed_response)
+    end
+
+    # Gets a specific Drive by its ID.
+    #
+    # @param drive_id [String] The ID of the Drive to get.
+    #
+    # @return [MicroslopOneDrive::Drive]
+    def drive(drive_id:)
+      response = get(path: "me/drives/#{drive_id}", query: {})
+      handle_error(response) unless response.success?
+      MicroslopOneDrive::Drive.new(response.parsed_response)
+    end
+
+    # Gets a specific DriveItem (folder or file) by its ID.
+    #
+    # @param item_id [String] The ID of the Drive Item to get.
+    #
+    # @return [MicroslopOneDrive::DriveItem]
+    def drive_item(item_id:)
+      response = get(path: "me/drive/items/#{item_id}", query: {})
+      handle_error(response) unless response.success?
+      MicroslopOneDrive::DriveItem.new(response.parsed_response)
+    end
+
+    # Asks if a DriveItem (folder or file) exists by its ID.
+    #
+    # @param item_id [String] The ID of the Drive Item to check.
+    #
+    # @return [Boolean]
+    def item_exists?(item_id:)
+      response = get(path: "me/drive/items/#{item_id}", query: {})
+
+      return false if response.code == 404
+      return true if response.success?
+
+      handle_error(response)
+    end
+
+    # Gets a delta of changes to a Drive.
+    #
+    # @param drive_id [String] The ID of the Drive to get the delta of.
+    # @param token [String] The token to use for the delta. If not provided, the initial delta will be returned.
+    #
+    # @return [MicroslopOneDrive::DriveItemList]
+    def delta(drive_id:, token: nil)
+      response = get(path: "me/drives/#{drive_id}/root/delta", query: {token: token})
+      handle_error(response) unless response.success?
+      MicroslopOneDrive::DriveItemList.new(response.parsed_response)
+    end
+
+    # Gets the permissions for a DriveItem (folder or file).
+    #
+    # @param item_id [String] The ID of the Drive Item to get the permissions of.
+    #
+    # @return [MicroslopOneDrive::PermissionList]
+    def permissions(item_id:)
+      response = get(path: "me/drive/items/#{item_id}/permissions", query: {})
+
+      return MicroslopOneDrive::PermissionList.new("value" => []) if response.code == 404
+
+      handle_error(response) unless response.success?
+      MicroslopOneDrive::PermissionList.new(response.parsed_response)
+    end
+
+    private
+
+    def get(path:, query: {})
+      response = HTTParty.get("#{BASE_URL}/#{path}", headers: @headers, query: query)
+
+      @debug_response_writer&.call(path, response.parsed_response)
+
+      response
+    end
+
+    def handle_error(response)
+      error = MicroslopOneDrive::Errors::ClientError.new(response.parsed_response, response.code)
+      raise error
+    end
+  end
+end

data/lib/microslop_one_drive/drive.rb

@@ -0,0 +1,14 @@
+module MicroslopOneDrive
+  class Drive
+    attr_reader :id, :name, :url, :drive_type
+
+    def initialize(drive_hash)
+      @drive_hash = drive_hash
+
+      @id = drive_hash.fetch("id", nil)
+      @name = drive_hash.fetch("name", nil)
+      @url = drive_hash.fetch("webUrl", nil)
+      @drive_type = drive_hash.fetch("driveType", nil)
+    end
+  end
+end

data/lib/microslop_one_drive/drive_item.rb

@@ -0,0 +1,99 @@
+module MicroslopOneDrive
+  class DriveItem
+    DIRECTORY_MIME_TYPE = "inode/directory".freeze
+
+    attr_reader :identifier,
+                :name,
+                :created_at,
+                :updated_at,
+                :url,
+                :size,
+                :file_or_folder,
+                :parent_identifier,
+                :mime_type,
+                :parent,
+                :children,
+                :path,
+                :full_path
+
+    def initialize(item_hash)
+      @item_hash = item_hash
+
+      @identifier = @item_hash.fetch("id", nil)
+      @name = @item_hash.fetch("name", nil)
+      @url = @item_hash.fetch("webUrl", nil)
+      @size = @item_hash.fetch("size", nil)
+
+      @created_at = Utils.safe_parse_time(@item_hash.fetch("createdDateTime", nil))
+      @updated_at = Utils.safe_parse_time(@item_hash.fetch("lastModifiedDateTime", nil))
+
+      if @item_hash.key?("file")
+        @file_or_folder = :file
+        @mime_type = @item_hash.dig("file", "mimeType")
+      elsif @item_hash.key?("folder")
+        @file_or_folder = :folder
+        @mime_type = DIRECTORY_MIME_TYPE
+      end
+
+      @parent_identifier = @item_hash.dig("parentReference", "id")
+
+      @deleted = @item_hash.dig("deleted", "state") == "deleted"
+
+      @path = build_path
+
+      @parent = nil
+      @children = []
+    end
+
+    def deleted?
+      @deleted
+    end
+
+    def shared?
+      @item_hash.key?("shared")
+    end
+
+    def file?
+      @file_or_folder == :file
+    end
+
+    def folder?
+      @file_or_folder == :folder
+    end
+
+    def set_parent(parent)
+      if @parent
+        @parent.remove_child(self)
+      end
+
+      @parent = parent
+      @parent.add_child(self)
+    end
+
+    def is_root?
+      @item_hash.key?("root")
+    end
+
+    protected
+
+    def add_child(child)
+      @children << child
+    end
+
+    def remove_child(child)
+      @children.delete(child)
+    end
+
+    private
+
+    def build_path
+      return "root:" if is_root?
+
+      full_parent_path = @item_hash.dig("parentReference", "path")
+      return nil if full_parent_path.nil?
+
+      full_path_with_name = File.join(full_parent_path, @name)
+      full_path_with_name.sub(/\A.*root:\//, "root:/")
+    end
+  end
+end

data/lib/microslop_one_drive/drive_item_list.rb

@@ -0,0 +1,32 @@
+module MicroslopOneDrive
+  class DriveItemList < ListResponse
+    attr_reader :items
+
+    def initialize(parsed_response)
+      super(parsed_response)
+
+      @parsed_response = parsed_response
+      @items = build_items
+    end
+
+    private
+
+    def build_items
+      items = @parsed_response.fetch("value", []).map do
+        MicroslopOneDrive::DriveItem.new(it)
+      end
+
+      set_parent_and_child_relationships(items)
+    end
+
+    def set_parent_and_child_relationships(items)
+      items.each do |item|
+        next if item.parent_identifier.nil?
+        parent = items.find { it.identifier == item.parent_identifier }
+        next if parent.nil?
+
+        item.set_parent(parent)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/drive_list.rb

@@ -0,0 +1,13 @@
+module MicroslopOneDrive
+  class DriveList < ListResponse
+    attr_reader :drives
+
+    def initialize(response_hash)
+      super(response_hash)
+
+      @drives = response_hash.fetch("value", []).map do
+        MicroslopOneDrive::Drive.new(it)
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/errors/client_error.rb

@@ -0,0 +1,13 @@
+module MicroslopOneDrive
+  module Errors
+    class ClientError < StandardError
+      attr_reader :response_body, :response_code
+
+      def initialize(response_body, response_code)
+        super(response_body)
+        @response_body = response_body
+        @response_code = response_code
+      end
+    end
+  end
+end

data/lib/microslop_one_drive/list_response.rb

@@ -0,0 +1,19 @@
+module MicroslopOneDrive
+  class ListResponse
+    attr_reader :next_link, :next_token, :delta_link, :delta_token
+
+    def initialize(response_hash)
+      @response_hash = response_hash
+
+      @next_link = response_hash.fetch("@odata.nextLink", nil)
+      @next_token = @next_link.split("?token=").last if @next_link && !@next_link.empty?
+
+      @delta_link = response_hash.fetch("@odata.deltaLink", nil)
+      @delta_token = @delta_link.split("?token=").last if @delta_link && !@delta_link.empty?
+    end
+
+    def next_page?
+      !next_link.nil?
+    end
+  end
+end

data/lib/microslop_one_drive/permission.rb

@@ -0,0 +1,11 @@
+module MicroslopOneDrive
+  class Permission
+    attr_reader :identifier, :role, :audience
+
+    def initialize(identifier:, role:, audience:)
+      @identifier = identifier
+      @role = role
+      @audience = audience
+    end
+  end
+end

data/lib/microslop_one_drive/permission_batch.rb

@@ -0,0 +1,60 @@
+module MicroslopOneDrive
+  class PermissionBatch
+    attr_reader :identifier, :role, :audiences
+
+    def initialize(parsed_response)
+      @parsed_response = parsed_response
+
+      @identifier = @parsed_response.fetch("id", nil)
+      @role = build_role
+      @audiences = build_audiences
+    end
+
+    def to_permissions
+      @audiences.map { Permission.new(identifier: @identifier, role: @role, audience: it) }
+    end
+
+    private
+
+    def build_role
+      roles = @parsed_response.fetch("roles", [])
+      roles.is_a?(Array) ? roles.first : roles
+    end
+
+    def build_audiences
+      audiences = []
+
+      audiences += audiences_from_site_users
+      audiences += audiences_from_anonymous_links
+
+      audiences.compact
+    end
+
+    def audiences_from_site_users
+      site_users = []
+      site_users += @parsed_response.fetch("grantedToIdentitiesV2", []).flat_map { it.fetch("siteUser", nil) }
+      site_users << @parsed_response.dig("grantedToV2", "siteUser")
+      site_users.compact!
+
+      site_users.map { Audience.from_site_user(it) }
+    end
+
+    def audiences_from_anonymous_links
+      link = @parsed_response.fetch("link", nil)
+      return [] if link.nil? || (link.respond_to?(:empty?) && link.empty?)
+
+      link_scope = link.fetch("scope", nil)
+
+      return [] unless link_scope == "anonymous" # I.e. an "anyone with the link" audience
+
+      [
+        Audience.new(
+          type: "anyone",
+          identifier: "anyone_with_the_link",
+          display_name: "Anyone with the link",
+          email_address: nil
+        )
+      ]
+    end
+  end
+end

data/lib/microslop_one_drive/permission_list.rb

@@ -0,0 +1,25 @@
+module MicroslopOneDrive
+  class PermissionList < ListResponse
+    attr_reader :permissions
+
+    def initialize(parsed_response)
+      super(parsed_response)
+
+      @parsed_response = parsed_response
+      @permissions = build_permissions
+    end
+
+    private
+
+    def build_permissions
+      value_list = @parsed_response.is_a?(Array) ? @parsed_response : @parsed_response.fetch("value", [])
+      permission_batches = value_list.map { MicroslopOneDrive::PermissionBatch.new(it) }
+
+      # At this stage, the permissions could contain multiple Audiences for the same Permission.
+      # This is because OneDrive can return multiple permissions for the same thing.
+      # For example, a file shared with one person and a public link will return in a single permission object.
+      # We therefore need to "explode" the permissions into multiple permissions, one for each Audience.
+      permission_batches.flat_map(&:to_permissions)
+    end
+  end
+end

data/lib/microslop_one_drive/user.rb

@@ -0,0 +1,12 @@
+module MicroslopOneDrive
+  class User
+    attr_reader :email_address, :display_name
+
+    def initialize(user_hash)
+      @user_hash = user_hash
+
+      @email_address = @user_hash.fetch("mail", nil)
+      @display_name = @user_hash.fetch("displayName", nil)
+    end
+  end
+end

data/lib/microslop_one_drive/utils.rb

@@ -0,0 +1,11 @@
+require "time"
+
+module MicroslopOneDrive
+  module Utils
+    def self.safe_parse_time(value)
+      return nil if value.nil? || value.to_s.strip.empty?
+
+      Time.parse(value)
+    end
+  end
+end

data/lib/microslop_one_drive/version.rb

@@ -0,0 +1,3 @@
+module MicroslopOneDrive
+  VERSION = "1.0.0"
+end

data/lib/microslop_one_drive.rb

@@ -0,0 +1,17 @@
+require "httparty"
+require "json"
+
+require_relative "microslop_one_drive/version"
+require_relative "microslop_one_drive/utils"
+require_relative "microslop_one_drive/errors/client_error"
+require_relative "microslop_one_drive/user"
+require_relative "microslop_one_drive/list_response"
+require_relative "microslop_one_drive/drive_list"
+require_relative "microslop_one_drive/drive"
+require_relative "microslop_one_drive/drive_item"
+require_relative "microslop_one_drive/drive_item_list"
+require_relative "microslop_one_drive/permission_list"
+require_relative "microslop_one_drive/permission_batch"
+require_relative "microslop_one_drive/permission"
+require_relative "microslop_one_drive/audience"
+require_relative "microslop_one_drive/client"

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: microslop_one_drive
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Bradley Marques
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.24'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.24'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: Lightweight value objects and HTTP client for OneDrive delta sync, item
+  metadata, and sharing permissions.
+email:
+- ''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/microslop_one_drive.rb
+- lib/microslop_one_drive/audience.rb
+- lib/microslop_one_drive/client.rb
+- lib/microslop_one_drive/drive.rb
+- lib/microslop_one_drive/drive_item.rb
+- lib/microslop_one_drive/drive_item_list.rb
+- lib/microslop_one_drive/drive_list.rb
+- lib/microslop_one_drive/errors/client_error.rb
+- lib/microslop_one_drive/list_response.rb
+- lib/microslop_one_drive/permission.rb
+- lib/microslop_one_drive/permission_batch.rb
+- lib/microslop_one_drive/permission_list.rb
+- lib/microslop_one_drive/user.rb
+- lib/microslop_one_drive/utils.rb
+- lib/microslop_one_drive/version.rb
+homepage: https://github.com/bradleymarques/microslop_one_drive
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/bradleymarques/microslop_one_drive
+  source_code_uri: https://github.com/bradleymarques/microslop_one_drive
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Ruby client helpers for Microsoft Graph OneDrive/SharePoint API (drive items,
+  delta, permissions).
+test_files: []