notionrb 1.3.0

data/spec/notion/api/endpoints/databases_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe Notion::Api::Endpoints::Databases do
+  let(:client) { Notion::Client.new }
+  let(:database_id) { 'dd428e9dd3fe4171870da7a1902c748b' }
+  let(:page_id) { 'c7fd1abe811444eabe779632ea33e581' }
+  let(:title) do
+    [
+      {
+        "text": {
+          "content": 'Orbit 💜 Notion'
+        }
+      }
+    ]
+  end
+  let(:properties) do
+    {
+      "Name": {
+        "title": {}
+      }
+    }
+  end
+
+  context 'databases' do
+    it 'queries', vcr: { cassette_name: 'database_query' } do
+      response = client.database_query(database_id: database_id)
+      expect(response.results.length).to be >= 1
+    end
+
+    it 'paginated queries', vcr: { cassette_name: 'paginated_database_query' } do
+      pages = []
+      client.database_query(database_id: database_id, page_size: 1) do |page|
+        pages.concat page.results
+      end
+      expect(pages.size).to be >= 1
+    end
+
+    it 'creates', vcr: { cassette_name: 'create_database' } do
+      response = client.create_database(
+        parent: { page_id: page_id },
+        title: title,
+        properties: properties
+      )
+      expect(response.title.first.plain_text).to eql 'Orbit 💜 Notion'
+    end
+
+    it 'creates with an explicit initial_data_source', vcr: { cassette_name: 'create_database' } do
+      response = client.create_database(
+        parent: { page_id: page_id },
+        title: title,
+        initial_data_source: { properties: properties }
+      )
+      expect(response.title.first.plain_text).to eql 'Orbit 💜 Notion'
+    end
+
+    it 'updates', vcr: { cassette_name: 'update_database' } do
+      response = client.update_database(
+        database_id: database_id,
+        title: title
+      )
+      expect(response.title.first.plain_text).to eql 'Orbit 💜 Notion'
+    end
+
+    it 'retrieves', vcr: { cassette_name: 'database' } do
+      response = client.database(database_id: database_id)
+      expect(response.title.first.plain_text).to eql 'Orbit 💜 Notion'
+    end
+  end
+end

data/spec/notion/api/endpoints/pages_spec.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe Notion::Api::Endpoints::Pages do
+  let(:client) { Notion::Client.new }
+  let(:database_id) { 'dd428e9d-d3fe-4171-870d-a7a1902c748b' }
+  let(:page_id) { 'c7fd1abe-8114-44ea-be77-9632ea33e581' }
+  let(:property_id) { '%5BIFC' }
+  let(:properties) do
+    {
+      "Name": {
+        "title": [
+          {
+            "text": {
+              "content": 'Another Notion page'
+            }
+          }
+        ]
+      }
+    }
+  end
+  let(:children) do
+    [
+      {
+        "object": 'block',
+        "type": 'heading_2',
+        "heading_2": {
+          "text": [{ "type": 'text', "text": { "content": 'A heading' } }]
+        }
+      }
+    ]
+  end
+
+  context 'pages' do
+    it 'retrieves', vcr: { cassette_name: 'page' } do
+      response = client.page(page_id: page_id)
+      expect(response.properties.Name.type).to eql 'title'
+      expect(response.properties.Name.title.first.plain_text).to eql 'Nicolas Goutay'
+    end
+
+    it 'creates', vcr: { cassette_name: 'create_page' } do
+      response = client.create_page(
+        parent: { database_id: database_id },
+        properties: properties,
+        children: children
+      )
+      expect(response.properties.Name.title.first.plain_text).to eql 'Another Notion page'
+    end
+
+    context 'when creating under a data source' do
+      let(:data_source_id) { '6a91c56ebc5e46699e34952e09ec53c0' }
+
+      it 'creates', vcr: { cassette_name: 'create_page_with_data_source' } do
+        response = client.create_page(
+          parent: { data_source_id: data_source_id },
+          properties: properties,
+          children: []
+        )
+        expect(response.parent.data_source_id).to eql '6a91c56e-bc5e-4669-9e34-952e09ec53c0'
+        expect(response.properties.Name.title.first.plain_text).to eql 'Another Notion page'
+      end
+    end
+
+    context 'when creating under parent page' do
+      let(:parent_page) { '0593a719-ff2e-44aa-a14a-2bf169429284' }
+      let(:properties) do
+        {
+          "title": [
+            {
+              "text": {
+                "content": 'Another Notion page'
+              }
+            }
+          ]
+        }
+      end
+      let(:children) do
+        [
+          {
+            "object": 'block',
+            "type": 'heading_2',
+            "heading_2": {
+              rich_text: [
+                {
+                  type: 'text',
+                  text: { content: 'My Heading 2' }
+                }
+              ]
+            }
+          }
+        ]
+      end
+
+      it 'creates', vcr: { cassette_name: 'create_page_with_parent_page' } do
+        response = client.create_page(
+          parent: { page_id: parent_page },
+          properties: properties,
+          children: children
+        )
+        expect(response.parent.page_id).to eql parent_page
+        expect(response.properties.title.title.first.plain_text).to eql 'Another Notion page'
+      end
+    end
+
+    it 'updates', vcr: { cassette_name: 'update_page' } do
+      properties = {
+        "Name": [
+          {
+            "text": {
+              "content": 'Nicolas Goutay'
+            }
+          }
+        ]
+      }
+      response = client.update_page(
+        page_id: page_id,
+        properties: properties
+      )
+      expect(response.properties.Name.title.first.plain_text).to eql 'Nicolas Goutay'
+    end
+
+    it 'retrieves a page property item', vcr: { cassette_name: 'page_property_item' } do
+      response = client.page_property_item(page_id: page_id, property_id: property_id)
+      expect(response.email).to eql 'nicolas@orbit.love'
+    end
+  end
+end

data/spec/notion/api/endpoints/search_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe Notion::Api::Endpoints::Search do
+  let(:client) { Notion::Client.new }
+
+  context 'search' do
+    it 'searches', vcr: { cassette_name: 'search' } do
+      response = client.search
+      expect(response.results.size).to eq 2
+    end
+
+    it 'searches with a query', vcr: { cassette_name: 'search_with_query' } do
+      response = client.search(query: 'Nicolas')
+      expect(response.results.size).to eq 1
+    end
+
+    it 'paginated search', vcr: { cassette_name: 'paginated_search' } do
+      results = []
+      client.search(page_size: 2) do |page|
+        results.concat page.results
+      end
+      expect(results.size).to eq 2
+    end
+  end
+end

data/spec/notion/api/endpoints/users_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe Notion::Api::Endpoints::Users do
+  let(:client) { Notion::Client.new }
+
+  context 'users' do
+    it 'me', vcr: { cassette_name: 'users_me' } do
+      response = client.me
+      expect(response.name).to eql 'Notion to Orbit'
+    end
+
+    it 'lists', vcr: { cassette_name: 'users_list' } do
+      response = client.users_list
+      expect(response.results.size).to be 1
+    end
+
+    it 'paginated list', vcr: { cassette_name: 'paginated_users_list' } do
+      members = []
+      client.users_list(page_size: 1) do |page|
+        members.concat page.results
+      end
+      expect(members.size).to eq 1
+    end
+
+    it 'retrieves', vcr: { cassette_name: 'users' } do
+      response = client.user(user_id: 'a8da8d30-c858-4c3d-87ad-3f2d477bd98d')
+      expect(response.name).to eql 'Nicolas Goutay'
+    end
+  end
+end

data/spec/notion/config_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Notion::Config do
+  describe '#configure' do
+    before do
+      Notion.configure do |config|
+        config.token = 'a token'
+      end
+    end
+
+    it 'sets token' do
+      expect(Notion.config.token).to eq 'a token'
+    end
+  end
+end

data/spec/notion/pagination/cursor_spec.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe Notion::Api::Pagination::Cursor do
+  let(:client) { Notion::Client.new }
+
+  context 'default cursor' do
+    let(:cursor) { described_class.new(client, 'users_list', {}) }
+
+    it 'provides a default page_size' do
+      expect(client).to receive(:users_list).with(page_size: 100)
+      cursor.first
+    end
+
+    it 'handles blank response metadata' do
+      expect(client).to receive(:users_list).once.and_return(Notion::Messages::Message.new)
+      cursor.to_a
+    end
+
+    it 'handles nil response metadata' do
+      expect(client).to(
+        receive(:users_list).once.and_return(Notion::Messages::Message.new(response: nil))
+      )
+      cursor.to_a
+    end
+
+    it 'paginates with a cursor inside response metadata' do
+      expect(client).to receive(:users_list).twice.and_return(
+        Notion::Messages::Message.new(has_more: true, next_cursor: 'next'),
+        Notion::Messages::Message.new
+      )
+      expect(cursor).not_to receive(:sleep)
+      cursor.to_a
+    end
+
+    context 'with rate limiting' do
+      let(:error) { Notion::Api::Errors::TooManyRequests.new({}) }
+
+      context 'with default max retries' do
+        it 'sleeps after a TooManyRequestsError' do
+          expect(client).to(
+            receive(:users_list)
+              .with(page_size: 100)
+              .ordered
+              .and_return(Notion::Messages::Message.new({ has_more: true, next_cursor: 'next' }))
+          )
+          expect(client).to(
+            receive(:users_list).with(page_size: 100, start_cursor: 'next').and_raise(error)
+          )
+          expect(cursor).to receive(:sleep).once.ordered.with(10)
+          expect(client).to(
+            receive(:users_list)
+              .with(page_size: 100, start_cursor: 'next')
+              .ordered
+              .and_return(Notion::Messages::Message.new)
+          )
+          cursor.to_a
+        end
+      end
+
+      context 'with a custom max_retries' do
+        let(:cursor) { described_class.new(client, 'users_list', max_retries: 4) }
+
+        it 'raises the error after hitting the max retries' do
+          expect(client).to(
+            receive(:users_list)
+              .with(page_size: 100)
+              .and_return(Notion::Messages::Message.new({ has_more: true, next_cursor: 'next' }))
+          )
+          expect(client).to(
+            receive(:users_list).with(page_size: 100, start_cursor: 'next').exactly(5).times.and_raise(error)
+          )
+          expect(cursor).to receive(:sleep).exactly(4).times.with(10)
+          expect { cursor.to_a }.to raise_error(error)
+        end
+      end
+
+      context 'with a custom retry_after' do
+        let(:cursor) { described_class.new(client, 'users_list', retry_after: 5) }
+
+        it 'sleeps for retry_after seconds after a TooManyRequestsError' do
+          expect(client).to(
+            receive(:users_list)
+              .with(page_size: 100)
+              .ordered
+              .and_return(Notion::Messages::Message.new({ has_more: true, next_cursor: 'next' }))
+          )
+          expect(client).to(
+            receive(:users_list).with(page_size: 100, start_cursor: 'next').ordered.and_raise(error)
+          )
+          expect(cursor).to receive(:sleep).once.ordered.with(5)
+          expect(client).to(
+            receive(:users_list)
+              .with(page_size: 100, start_cursor: 'next')
+              .ordered
+              .and_return(Notion::Messages::Message.new)
+          )
+          cursor.to_a
+        end
+      end
+    end
+  end
+
+  context 'with a custom page_size' do
+    let(:cursor) { described_class.new(client, 'users_list', page_size: 42) }
+
+    it 'overrides default page_size' do
+      expect(client).to receive(:users_list).with(page_size: 42)
+      cursor.first
+    end
+  end
+
+  context 'with a custom sleep_interval' do
+    let(:cursor) { described_class.new(client, 'users_list', sleep_interval: 3) }
+
+    it 'sleeps between requests' do
+      expect(client).to receive(:users_list).exactly(3).times.and_return(
+        Notion::Messages::Message.new(has_more: true, next_cursor: 'next_a'),
+        Notion::Messages::Message.new(has_more: true, next_cursor: 'next_b'),
+        Notion::Messages::Message.new
+      )
+      expect(cursor).to receive(:sleep).with(3).twice
+      cursor.to_a
+    end
+  end
+end

data/spec/notion/version_spec.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Notion do
+  it 'has a version' do
+    expect(Notion::VERSION).not_to be nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
+
+require 'rubygems'
+require 'rspec'
+require 'timecop'
+
+require 'notion_ruby_client'
+
+
+Dir[File.join(File.dirname(__FILE__), 'support', '**/*.rb')].each do |file|
+  require file
+end
+
+Notion.configure do |config|
+  config.token = ENV['NOTION_API_TOKEN']
+end
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = '.rspec_status'
+end

data/spec/support/token.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+RSpec.configure do |config|
+  config.before do
+    @old_token = Notion::Config.token
+  end
+  config.after do
+    Notion::Config.reset
+    Notion::Config.token = @old_token
+  end
+end

data/spec/support/vcr.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+require 'vcr'
+require 'webmock/rspec'
+
+VCR.configure do |config|
+  config.cassette_library_dir = 'spec/fixtures/notion'
+  config.hook_into :webmock
+  # config.default_cassette_options = { record: :new_episodes }
+  config.configure_rspec_metadata!
+  config.before_record do |i|
+    if ENV.key?('NOTION_API_TOKEN')
+      i.request.headers['Authorization'].first.gsub!(ENV['NOTION_API_TOKEN'], '<NOTION_API_TOKEN>')
+    end
+    i.response.body.force_encoding('UTF-8')
+  end
+end