diff --git a/.env.test b/.env.test index 4cd76d6f0a9..ef32c81a618 100644 --- a/.env.test +++ b/.env.test @@ -15,6 +15,10 @@ STRIPE_PUBLIC_TEST_API_KEY="bogus_stripe_publishable_key" SITE_URL="test.host" +# OIDC Settings for DFC authentication +# Find secrets in BitWarden. +# To get a refresh token: log into the OIDC provider, connect your OFN user to it at /admin/oidc_settings, then copy the token from the database: +# ./bin/rails runner 'puts "OPENID_REFRESH_TOKEN=\"#{OidcAccount.last.refresh_token}\""' OPENID_APP_ID="test-provider" OPENID_APP_SECRET="dummy-openid-app-secret-token" OPENID_REFRESH_TOKEN="dummy-refresh-token" diff --git a/app/jobs/open_order_cycle_job.rb b/app/jobs/open_order_cycle_job.rb new file mode 100644 index 00000000000..80c4e1d7b88 --- /dev/null +++ b/app/jobs/open_order_cycle_job.rb @@ -0,0 +1,67 @@ +# frozen_string_literal: true + +# Run any pre-conditions and mark order cycle as open. +# +# Currently, an order cycle is considered open in the shopfront when orders_open_at >= now. +# But now there are some pre-conditions for opening an order cycle, so we would like to change that. +# Instead, the presence of opened_at (and absence of processed_at) should indicate it is open. +class OpenOrderCycleJob < ApplicationJob + sidekiq_options retry_for: 10.minutes + + def perform(order_cycle_id) + ActiveRecord::Base.transaction do + # Fetch order cycle if it's still unopened, and lock DB row until finished + order_cycle = OrderCycle.lock.find_by!(id: order_cycle_id, opened_at: nil) + + sync_remote_variants(order_cycle) + + # Mark as opened + opened_at = Time.zone.now + order_cycle.update_columns(opened_at:) + + # And notify any subscribers + OrderCycles::WebhookService.create_webhook_job(order_cycle, 'order_cycle.opened', opened_at) + end + end + + private + + def sync_remote_variants(order_cycle) + # Sync any remote variants for each supplier + order_cycle.suppliers.each do |supplier| + links = variant_links_for(order_cycle, supplier) + next if links.empty? + + # Find authorised user to access remote products + dfc_user = supplier.owner # we assume the owner's account is the one used to import from dfc. + + import_variants(links, dfc_user) + end + end + + # Fetch all remote variants for this supplier in the order cycle + def variant_links_for(order_cycle, supplier) + variants = order_cycle.exchanges.incoming.from_enterprise(supplier) + .joins(:exchange_variants).select('exchange_variants.variant_id') + SemanticLink.where(subject_id: variants) + end + + def import_variants(links, dfc_user) + # Find any catalogues associated with the variants + catalogs = links.group_by do |link| + FdcUrlBuilder.new(link.semantic_id).catalog_url + end + + # Import selected variants from each catalog + catalogs.each do |catalog_url, catalog_links| + catalog = DfcCatalog.load(dfc_user, catalog_url) + catalog.apply_wholesale_values! + + catalog_links.each do |link| + catalog_item = catalog.item(link.semantic_id) + + SuppliedProductImporter.update_product(catalog_item, link.subject) if catalog_item + end + end + end +end diff --git a/app/jobs/order_cycle_closing_job.rb b/app/jobs/order_cycle_closing_job.rb index 31ca6fb2a28..3a695e820ad 100644 --- a/app/jobs/order_cycle_closing_job.rb +++ b/app/jobs/order_cycle_closing_job.rb @@ -25,8 +25,7 @@ def send_notifications def mark_as_processed OrderCycle.where(id: recently_closed_order_cycles).update_all( - processed_at: Time.zone.now, - updated_at: Time.zone.now + processed_at: Time.zone.now ) end end diff --git a/app/jobs/order_cycle_opened_job.rb b/app/jobs/order_cycle_opened_job.rb deleted file mode 100644 index 3b4cee16dbe..00000000000 --- a/app/jobs/order_cycle_opened_job.rb +++ /dev/null @@ -1,27 +0,0 @@ -# frozen_string_literal: true - -# Trigger jobs for any order cycles that recently opened -class OrderCycleOpenedJob < ApplicationJob - def perform - ActiveRecord::Base.transaction do - recently_opened_order_cycles.find_each do |order_cycle| - OrderCycles::WebhookService.create_webhook_job(order_cycle, 'order_cycle.opened') - end - mark_as_opened(recently_opened_order_cycles) - end - end - - private - - def recently_opened_order_cycles - @recently_opened_order_cycles ||= OrderCycle - .where(opened_at: nil) - .where(orders_open_at: 1.hour.ago..Time.zone.now) - .lock.order(:id) - end - - def mark_as_opened(order_cycles) - now = Time.zone.now - order_cycles.update_all(opened_at: now, updated_at: now) - end -end diff --git a/app/jobs/trigger_order_cycles_to_open_job.rb b/app/jobs/trigger_order_cycles_to_open_job.rb new file mode 100644 index 00000000000..ca1d5c83931 --- /dev/null +++ b/app/jobs/trigger_order_cycles_to_open_job.rb @@ -0,0 +1,18 @@ +# frozen_string_literal: true + +# Trigger jobs for any order cycles that recently opened +class TriggerOrderCyclesToOpenJob < ApplicationJob + def perform + recently_opened_order_cycles.find_each do |order_cycle| + OpenOrderCycleJob.perform_later(order_cycle.id) + end + end + + private + + def recently_opened_order_cycles + OrderCycle + .where(opened_at: nil) + .where(orders_open_at: 1.hour.ago..Time.zone.now) + end +end diff --git a/app/jobs/webhook_delivery_job.rb b/app/jobs/webhook_delivery_job.rb index 1196e6a1d6d..6004b0d6f19 100644 --- a/app/jobs/webhook_delivery_job.rb +++ b/app/jobs/webhook_delivery_job.rb @@ -13,11 +13,11 @@ class FailedWebhookRequestError < StandardError; end queue_as :default - def perform(url, event, payload) + def perform(url, event, payload, at: Time.zone.now) body = { id: job_id, - at: Time.zone.now.to_s, event:, + at: at.to_s, data: payload, } diff --git a/app/services/order_cycles/webhook_service.rb b/app/services/order_cycles/webhook_service.rb index f12c94ea1bf..b45c5c6e411 100644 --- a/app/services/order_cycles/webhook_service.rb +++ b/app/services/order_cycles/webhook_service.rb @@ -5,9 +5,9 @@ module OrderCycles class WebhookService - def self.create_webhook_job(order_cycle, event) + def self.create_webhook_job(order_cycle, event, at) webhook_payload = order_cycle - .slice(:id, :name, :orders_open_at, :orders_close_at, :coordinator_id) + .slice(:id, :name, :orders_open_at, :opened_at, :orders_close_at, :coordinator_id) .merge(coordinator_name: order_cycle.coordinator.name) # Endpoints for coordinator owner @@ -17,7 +17,7 @@ def self.create_webhook_job(order_cycle, event) webhook_endpoints |= order_cycle.distributors.map(&:owner).flat_map(&:webhook_endpoints) webhook_endpoints.each do |endpoint| - WebhookDeliveryJob.perform_later(endpoint.url, event, webhook_payload) + WebhookDeliveryJob.perform_later(endpoint.url, event, webhook_payload, at:) end end end diff --git a/config/sidekiq.yml b/config/sidekiq.yml index eab2b061dbc..bcd4e31909c 100644 --- a/config/sidekiq.yml +++ b/config/sidekiq.yml @@ -15,7 +15,7 @@ every: "5m" SubscriptionConfirmJob: every: "5m" - OrderCycleOpenedJob: + TriggerOrderCyclesToOpenJob: every: "5m" OrderCycleClosingJob: every: "5m" diff --git a/spec/factories/oidc_account_factory.rb b/spec/factories/oidc_account_factory.rb index 4b0e12130f2..a636e3663bf 100644 --- a/spec/factories/oidc_account_factory.rb +++ b/spec/factories/oidc_account_factory.rb @@ -6,6 +6,7 @@ uid { user&.email || generate(:random_email) } # This is a live test account authenticated via Les Communes. + # See .env.test for tips on connecting the account for recording VCR cassettes. factory :testdfc_account do uid { "testdfc@protonmail.com" } refresh_token { ENV.fetch("OPENID_REFRESH_TOKEN") } diff --git a/spec/fixtures/vcr_cassettes/OpenOrderCycleJob/syncing_remote_products/synchronises_products_from_a_FDC_catalog.yml b/spec/fixtures/vcr_cassettes/OpenOrderCycleJob/syncing_remote_products/synchronises_products_from_a_FDC_catalog.yml new file mode 100644 index 00000000000..7fe3347c06c --- /dev/null +++ b/spec/fixtures/vcr_cassettes/OpenOrderCycleJob/syncing_remote_products/synchronises_products_from_a_FDC_catalog.yml @@ -0,0 +1,198 @@ +--- +http_interactions: +- request: + method: get + uri: https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts + body: + encoding: US-ASCII + string: '' + headers: + Content-Type: + - application/json + Authorization: + - "" + User-Agent: + - Faraday v2.9.0 + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 403 + message: Forbidden + headers: + Server: + - openresty + Date: + - Wed, 26 Feb 2025 04:26:44 GMT + Content-Type: + - application/json; charset=utf-8 + Content-Length: + - '78' + Connection: + - keep-alive + X-Powered-By: + - Express + Access-Control-Allow-Origin: + - "*" + Etag: + - W/"4e-vJeBLxgahmv23yP9gdPJW/woako" + Strict-Transport-Security: + - max-age=15811200 + body: + encoding: UTF-8 + string: '{"message":"User access denied - token missing","error":"User not authorized"}' + recorded_at: Wed, 26 Feb 2025 04:26:41 GMT +- request: + method: get + uri: https://login.lescommuns.org/auth/realms/data-food-consortium/.well-known/openid-configuration + body: + encoding: US-ASCII + string: '' + headers: + User-Agent: + - SWD 2.0.3 + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Date: + - Wed, 26 Feb 2025 04:26:45 GMT + Content-Type: + - application/json;charset=UTF-8 + Transfer-Encoding: + - chunked + Connection: + - keep-alive + Vary: + - Accept-Encoding + Set-Cookie: + - INGRESSCOOKIE=1740544006.542.53801.455812|78230f584c0d7db97d376e98de5321dc; + Path=/; Secure; HttpOnly + Cache-Control: + - no-cache, must-revalidate, no-transform, no-store + Referrer-Policy: + - no-referrer + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-Xss-Protection: + - 1; mode=block + body: + encoding: ASCII-8BIT + string: '{"issuer":"https://login.lescommuns.org/auth/realms/data-food-consortium","authorization_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/auth","token_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/token","introspection_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/token/introspect","userinfo_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/userinfo","end_session_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/logout","frontchannel_logout_session_supported":true,"frontchannel_logout_supported":true,"jwks_uri":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/certs","check_session_iframe":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/login-status-iframe.html","grant_types_supported":["authorization_code","implicit","refresh_token","password","client_credentials","urn:openid:params:grant-type:ciba","urn:ietf:params:oauth:grant-type:device_code"],"acr_values_supported":["0","1"],"response_types_supported":["code","none","id_token","token","id_token + token","code id_token","code token","code id_token token"],"subject_types_supported":["public","pairwise"],"id_token_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512"],"id_token_encryption_alg_values_supported":["RSA-OAEP","RSA-OAEP-256","RSA1_5"],"id_token_encryption_enc_values_supported":["A256GCM","A192GCM","A128GCM","A128CBC-HS256","A192CBC-HS384","A256CBC-HS512"],"userinfo_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512","none"],"userinfo_encryption_alg_values_supported":["RSA-OAEP","RSA-OAEP-256","RSA1_5"],"userinfo_encryption_enc_values_supported":["A256GCM","A192GCM","A128GCM","A128CBC-HS256","A192CBC-HS384","A256CBC-HS512"],"request_object_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512","none"],"request_object_encryption_alg_values_supported":["RSA-OAEP","RSA-OAEP-256","RSA1_5"],"request_object_encryption_enc_values_supported":["A256GCM","A192GCM","A128GCM","A128CBC-HS256","A192CBC-HS384","A256CBC-HS512"],"response_modes_supported":["query","fragment","form_post","query.jwt","fragment.jwt","form_post.jwt","jwt"],"registration_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/clients-registrations/openid-connect","token_endpoint_auth_methods_supported":["private_key_jwt","client_secret_basic","client_secret_post","tls_client_auth","client_secret_jwt"],"token_endpoint_auth_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512"],"introspection_endpoint_auth_methods_supported":["private_key_jwt","client_secret_basic","client_secret_post","tls_client_auth","client_secret_jwt"],"introspection_endpoint_auth_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512"],"authorization_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512"],"authorization_encryption_alg_values_supported":["RSA-OAEP","RSA-OAEP-256","RSA1_5"],"authorization_encryption_enc_values_supported":["A256GCM","A192GCM","A128GCM","A128CBC-HS256","A192CBC-HS384","A256CBC-HS512"],"claims_supported":["aud","sub","iss","auth_time","name","given_name","family_name","preferred_username","email","acr"],"claim_types_supported":["normal"],"claims_parameter_supported":true,"scopes_supported":["openid","microprofile-jwt","phone","roles","profile","email","address","web-origins","acr","offline_access","ReadProduct"],"request_parameter_supported":true,"request_uri_parameter_supported":true,"require_request_uri_registration":true,"code_challenge_methods_supported":["plain","S256"],"tls_client_certificate_bound_access_tokens":true,"revocation_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/revoke","revocation_endpoint_auth_methods_supported":["private_key_jwt","client_secret_basic","client_secret_post","tls_client_auth","client_secret_jwt"],"revocation_endpoint_auth_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512"],"backchannel_logout_supported":true,"backchannel_logout_session_supported":true,"device_authorization_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/auth/device","backchannel_token_delivery_modes_supported":["poll","ping"],"backchannel_authentication_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/ext/ciba/auth","backchannel_authentication_request_signing_alg_values_supported":["PS384","ES384","RS384","ES256","RS256","ES512","PS256","PS512","RS512"],"require_pushed_authorization_requests":false,"pushed_authorization_request_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/ext/par/request","mtls_endpoint_aliases":{"token_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/token","revocation_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/revoke","introspection_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/token/introspect","device_authorization_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/auth/device","registration_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/clients-registrations/openid-connect","userinfo_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/userinfo","pushed_authorization_request_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/ext/par/request","backchannel_authentication_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/ext/ciba/auth"},"authorization_response_iss_parameter_supported":true}' + recorded_at: Wed, 26 Feb 2025 04:26:41 GMT +- request: + method: post + uri: https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/token + body: + encoding: UTF-8 + string: grant_type=refresh_token&refresh_token= + headers: + User-Agent: + - Rack::OAuth2 (2.2.1) + Authorization: + - "" + Content-Type: + - application/x-www-form-urlencoded + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Date: + - Wed, 26 Feb 2025 04:26:46 GMT + Content-Type: + - application/json + Transfer-Encoding: + - chunked + Connection: + - keep-alive + Vary: + - Accept-Encoding + Set-Cookie: + - INGRESSCOOKIE=1740544007.438.54830.143060|78230f584c0d7db97d376e98de5321dc; + Path=/; Secure; HttpOnly + Cache-Control: + - no-store + Pragma: + - no-cache + Referrer-Policy: + - no-referrer + Strict-Transport-Security: + - max-age=31536000; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-Xss-Protection: + - 1; mode=block + body: + encoding: ASCII-8BIT + string: '{"access_token":"","expires_in":1800,"refresh_expires_in":0,"refresh_token":"","token_type":"Bearer","id_token":"","not-before-policy":0,"session_state":"c1863fca-32d6-427a-a860-2d16734e6715","scope":"openid + profile email offline_access"}' + recorded_at: Wed, 26 Feb 2025 04:26:41 GMT +- request: + method: get + uri: https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts + body: + encoding: US-ASCII + string: '' + headers: + Content-Type: + - application/json + Authorization: + - "" + User-Agent: + - Faraday v2.9.0 + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Server: + - openresty + Date: + - Wed, 26 Feb 2025 04:26:48 GMT + Content-Type: + - text/html; charset=utf-8 + Content-Length: + - '32854' + Connection: + - keep-alive + X-Powered-By: + - Express + Access-Control-Allow-Origin: + - "*" + Etag: + - W/"8056-R5l3QaspJAaqIP/JgVAD/G9OI60" + Set-Cookie: + - SRVGROUP=common; path=/; HttpOnly + X-Resolver-Ip: + - 185.172.100.60 + Strict-Transport-Security: + - max-age=15811200 + body: + encoding: ASCII-8BIT + string: !binary |- + {"@context":"https://www.datafoodconsortium.org","@graph":[{"@id":"_:b263986","@type":"dfc-b:QuantitativeValue","dfc-b:hasUnit":"dfc-m:Kilogram","dfc-b:value":"0.04"},{"@id":"_:b263987","@type":"dfc-b:Price","dfc-b:VATrate":"0","dfc-b:hasUnit":"dfc-m:PoundSterling","dfc-b:value":"6.25"},{"@id":"_:b263988","@type":"dfc-b:QuantitativeValue","dfc-b:hasUnit":"dfc-m:Kilogram","dfc-b:value":"0.4"},{"@id":"_:b263989","@type":"dfc-b:Price","dfc-b:VATrate":"0","dfc-b:hasUnit":"dfc-m:PoundSterling","dfc-b:value":"2.09"},{"@id":"_:b263990","@type":"dfc-b:QuantitativeValue","dfc-b:hasUnit":"dfc-m:Kilogram","dfc-b:value":"0.3"},{"@id":"_:b263991","@type":"dfc-b:Price","dfc-b:VATrate":"0","dfc-b:hasUnit":"dfc-m:PoundSterling","dfc-b:value":"2.49"},{"@id":"_:b263992","@type":"dfc-b:QuantitativeValue","dfc-b:hasUnit":"dfc-m:Kilogram","dfc-b:value":"0"},{"@id":"_:b263993","@type":"dfc-b:Price","dfc-b:VATrate":"0","dfc-b:hasUnit":"dfc-m:PoundSterling","dfc-b:value":"5.95"},{"@id":"_:b263994","@type":"dfc-b:QuantitativeValue","dfc-b:hasUnit":"dfc-m:Kilogram","dfc-b:value":"0.24"},{"@id":"_:b263995","@type":"dfc-b:Price","dfc-b:VATrate":"0","dfc-b:hasUnit":"dfc-m:PoundSterling","dfc-b:value":"30.20"},{"@id":"_:b263996","@type":"dfc-b:QuantitativeValue","dfc-b:hasUnit":"dfc-m:Kilogram","dfc-b:value":"4.8"},{"@id":"_:b263997","@type":"dfc-b:Price","dfc-b:VATrate":"0","dfc-b:hasUnit":"dfc-m:PoundSterling","dfc-b:value":"18.85"},{"@id":"_:b263998","@type":"dfc-b:QuantitativeValue","dfc-b:hasUnit":"dfc-m:Kilogram","dfc-b:value":"2.4"},{"@id":"_:b263999","@type":"dfc-b:Price","dfc-b:VATrate":"0","dfc-b:hasUnit":"dfc-m:PoundSterling","dfc-b:value":"14.95"},{"@id":"_:b264000","@type":"dfc-b:QuantitativeValue","dfc-b:hasUnit":"dfc-m:Kilogram","dfc-b:value":"0"},{"@id":"_:b264001","@type":"dfc-b:Price","dfc-b:VATrate":"0","dfc-b:hasUnit":"dfc-m:PoundSterling","dfc-b:value":"45.00"},{"@id":"_:b264002","@type":"dfc-b:QuantitativeValue","dfc-b:hasUnit":"dfc-m:Piece","dfc-b:value":"6"},{"@id":"_:b264003","@type":"dfc-b:QuantitativeValue","dfc-b:hasUnit":"dfc-m:Piece","dfc-b:value":"1"},{"@id":"_:b264004","@type":"dfc-b:QuantitativeValue","dfc-b:hasUnit":"dfc-m:Piece","dfc-b:value":"12"},{"@id":"_:b264005","@type":"dfc-b:QuantitativeValue","dfc-b:hasUnit":"dfc-m:Piece","dfc-b:value":"1"},{"@id":"_:b264006","@type":"dfc-b:QuantitativeValue","dfc-b:hasUnit":"dfc-m:Piece","dfc-b:value":"8"},{"@id":"_:b264007","@type":"dfc-b:QuantitativeValue","dfc-b:hasUnit":"dfc-m:Piece","dfc-b:value":"1"},{"@id":"_:b264008","@type":"dfc-b:QuantitativeValue","dfc-b:hasUnit":"dfc-m:Piece","dfc-b:value":"10"},{"@id":"_:b264009","@type":"dfc-b:QuantitativeValue","dfc-b:hasUnit":"dfc-m:Piece","dfc-b:value":"1"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466238259","@type":"dfc-b:SuppliedProduct","dfc-b:description":"<table width=\"100%\">\n<tbody>\n<tr style=\"border: 0px;\" data-mce-style=\"border: 0px;\">\n<td bgcolor=\"#d6fbed\" style=\"color: #000000; border: 0px; width: 526px;\" data-mce-style=\"color: #000000; border: 0px; width: 526px;\"><b>This rich, intense and deeply flavoured 6-year old apple balsamic vinegar is made using the traditional Italian method of reduction and concentration of the juice over a lengthy period of time, rather than by adding flavouring and colouring. </b></td>\n</tr>\n</tbody>\n</table>\n<p>Liberty Fields produce small batches of superb syrup, balsamic vinegar, cider and vodka by hand from the fruit of their own Dorset apple orchards, planted from 2010.<br></p>\n<p>The balsamic vinegar is aged for 6 years in barrels. The only ingredient is apples.</p>\n<h5 class=\"product-detail-title\">How to use</h5>\n<p>Use like Italian balsamic vinegar. <span data-mce-fragment=\"1\">As well as using on salads, it’s a great partner for grilled meats or charcuterie; a drop brings out the taste of strawberries and other soft fruits; and it can really enhance a stew, sauce or a soup. </span></p>\n<h5 class=\"product-detail-title\">To store<br>\n</h5>\n<p>For best before date see pack. Store in a cool, dry place.<br></p>\n<h5 class=\"product-detail-title\">Ingredients</h5>\n<p>Apples<br></p>\n<h5 class=\"product-detail-title\">Allergy information</h5>\n<p>No allergens.</p><h5 class=\"product-detail-title\">More</h5>\n<p>Product of Dorset<br>Suitable for vegans and vegetarians<br></p>","dfc-b:hasQuantity":"_:b263986","dfc-b:image":"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Liberty-Fields-Apple-Balsamic-Vinegar-40ml_79617eea-ab8c-4070-9e4d-711bf030ad07.jpg?v=1677760772","dfc-b:name":"Apple Balsamic Vinegar - Retail bottle, 40ml","dfc-b:referencedBy":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466238259/CatalogItem"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466238259/AsPlannedConsumptionFlow","@type":"dfc-b:AsPlannedConsumptionFlow","dfc-b:consumes":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466238259","dfc-b:hasQuantity":"_:b264002"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466238259/AsPlannedProductionFlow","@type":"dfc-b:AsPlannedProductionFlow","dfc-b:hasQuantity":"_:b264003","dfc-b:produces":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466271027"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466238259/AsPlannedTransformation","@type":"dfc-b:AsPlannedTransformation","dfc-b:hasIncome":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466238259/AsPlannedConsumptionFlow","dfc-b:hasOutcome":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466238259/AsPlannedProductionFlow"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466238259/CatalogItem","@type":"dfc-b:CatalogItem","dfc-b:offeredThrough":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466238259/Offer","dfc-b:sku":"LIB/NABVI/BF","dfc-b:stockLimitation":"-1"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466238259/Offer","@type":"dfc-b:Offer","dfc-b:hasPrice":{"@id":"_:b263987"}},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466271027","@type":"dfc-b:SuppliedProduct","dfc-b:description":"<table width=\"100%\">\n<tbody>\n<tr style=\"border: 0px;\" data-mce-style=\"border: 0px;\">\n<td bgcolor=\"#d6fbed\" style=\"color: #000000; border: 0px; width: 526px;\" data-mce-style=\"color: #000000; border: 0px; width: 526px;\"><b>This rich, intense and deeply flavoured 6-year old apple balsamic vinegar is made using the traditional Italian method of reduction and concentration of the juice over a lengthy period of time, rather than by adding flavouring and colouring. </b></td>\n</tr>\n</tbody>\n</table>\n<p>Liberty Fields produce small batches of superb syrup, balsamic vinegar, cider and vodka by hand from the fruit of their own Dorset apple orchards, planted from 2010.<br></p>\n<p>The balsamic vinegar is aged for 6 years in barrels. The only ingredient is apples.</p>\n<h5 class=\"product-detail-title\">How to use</h5>\n<p>Use like Italian balsamic vinegar. <span data-mce-fragment=\"1\">As well as using on salads, it’s a great partner for grilled meats or charcuterie; a drop brings out the taste of strawberries and other soft fruits; and it can really enhance a stew, sauce or a soup. </span></p>\n<h5 class=\"product-detail-title\">To store<br>\n</h5>\n<p>For best before date see pack. Store in a cool, dry place.<br></p>\n<h5 class=\"product-detail-title\">Ingredients</h5>\n<p>Apples<br></p>\n<h5 class=\"product-detail-title\">Allergy information</h5>\n<p>No allergens.</p><h5 class=\"product-detail-title\">More</h5>\n<p>Product of Dorset<br>Suitable for vegans and vegetarians<br></p>","dfc-b:hasQuantity":"_:b263994","dfc-b:image":"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Liberty-Fields-Apple-Balsamic-Vinegar-40ml_79617eea-ab8c-4070-9e4d-711bf030ad07.jpg?v=1677760772","dfc-b:name":"Apple Balsamic Vinegar - Case, 6 x 40ml","dfc-b:referencedBy":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466271027/CatalogItem"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466271027/CatalogItem","@type":"dfc-b:CatalogItem","dfc-b:offeredThrough":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466271027/Offer","dfc-b:sku":"LIB/NABVI/C6","dfc-b:stockLimitation":"1"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466271027/Offer","@type":"dfc-b:Offer","dfc-b:hasPrice":{"@id":"_:b263995"}},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466467635","@type":"dfc-b:SuppliedProduct","dfc-b:description":"<table width=\"100%\">\n<tbody>\n<tr style=\"border: 0px;\">\n<td bgcolor=\"#d6fbed\" style=\"color: #000000; border: 0px;\"><strong>They're back!</strong></td>\n</tr>\n</tbody>\n</table>\n<p><strong>Think baked beans are British? They are now! We use only British-grown fava beans - Britain's original bean, grown here since the Iron Age. Our Baked British Beans are deliciously different, with large meaty fava beans in a tasty tomato sauce.</strong></p>\n<p><strong><a title=\"What are fava beans? Aren't they just broad beans?\" href=\"/blogs/news/what-are-fava-beans-are-they-just-broad-beans\" data-mce-fragment=\"1\" data-mce-href=\"/blogs/news/what-are-fava-beans-are-they-just-broad-beans\">What are fava beans? Find out here...</a></strong></p>\n<!-- split --><h3>Complete Product Details</h3><p>Our Baked British Beans are cooked and ready to eat, hot or cold. They're good served on toast but also delicious added to stews, curries or casseroles. Or even in a pie.</p>\n<h5 class=\"product-detail-title\">Cooking instructions</h5>\n<p><strong>Cooking on the Hob</strong><br>Empty contents into saucepan. Heat gently for 4-5 minutes while stirring. For best flavour do not boil or overcook. Do not reheat.</p>\n<p><strong>Microwave Cooking</strong><br>Empty contents into a non-metallic bowl and cover. Heat for 2 to 3 minutes, stirring halfway. Check the food is hot, stir well and serve. Do not reheat.</p>\n<h5 class=\"product-detail-title\">To Store</h5>\n<p>Store in a cool, dry place. Once opened, transfer contents to a non-metallic container, cover refrigerate and use with 2 days.</p>\n<h5 class=\"product-detail-title\">Ingredients</h5>\n<p>Fava Beans (Broad Beans) (42%), Water, Tomato Puree, Sugar, Modified Maize Starch, Salt, Herbs &amp; Spices, Concentrated Lemon Juice</p>\n<h5 class=\"product-detail-title\">Allergy information</h5>\n<p>No Allergens</p>\n<table width=\"100%\">\n<tbody>\n<tr>\n<td><strong>Typical values</strong></td>\n<td><strong>Per 100g</strong></td>\n</tr>\n<tr>\n<td>Energy</td>\n<td>292kJ (69kcal)</td>\n</tr>\n<tr>\n<td>Fat</td>\n<td>0.4g</td>\n</tr>\n<tr>\n<td>of which saturates</td>\n<td>0.1g</td>\n</tr>\n<tr>\n<td>Carbohydrate</td>\n<td>10.1g</td>\n</tr>\n<tr>\n<td>of which sugars</td>\n<td>4.6g</td>\n</tr>\n<tr>\n<td>Fibre</td>\n<td>5g</td>\n</tr>\n<tr>\n<td>Protein</td>\n<td>4g</td>\n</tr>\n<tr>\n<td>Salt</td>\n<td>0.6g</td>\n</tr>\n</tbody>\n</table><h5 class=\"product-detail-title\">More</h5>\n<p>Delicious, nutritious and good for the soil, fava beans are a variety of broad bean, Vicia faba, left to ripen and dry before harvest. They’re also known as field beans, horse beans, Windsor beans or ful.</p>\n<p>Suitable for vegans and vegetarians</p>\n","dfc-b:hasQuantity":"_:b263988","dfc-b:image":"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Pack-Can-Baked-Beans-1800x6_983x656_513758e6-2616-4687-a8b2-ba6dde864923.jpg?v=1677760778","dfc-b:name":"Baked British Beans - Retail can, 400g (can)","dfc-b:referencedBy":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466467635/CatalogItem"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466467635/AsPlannedConsumptionFlow","@type":"dfc-b:AsPlannedConsumptionFlow","dfc-b:consumes":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466467635","dfc-b:hasQuantity":"_:b264004"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466467635/AsPlannedProductionFlow","@type":"dfc-b:AsPlannedProductionFlow","dfc-b:hasQuantity":"_:b264005","dfc-b:produces":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466500403"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466467635/AsPlannedTransformation","@type":"dfc-b:AsPlannedTransformation","dfc-b:hasIncome":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466467635/AsPlannedConsumptionFlow","dfc-b:hasOutcome":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466467635/AsPlannedProductionFlow"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466467635/CatalogItem","@type":"dfc-b:CatalogItem","dfc-b:offeredThrough":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466467635/Offer","dfc-b:sku":"NCBB/T4","dfc-b:stockLimitation":"-1"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466467635/Offer","@type":"dfc-b:Offer","dfc-b:hasPrice":{"@id":"_:b263989"}},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466500403","@type":"dfc-b:SuppliedProduct","dfc-b:description":"<table width=\"100%\">\n<tbody>\n<tr style=\"border: 0px;\">\n<td bgcolor=\"#d6fbed\" style=\"color: #000000; border: 0px;\"><strong>They're back!</strong></td>\n</tr>\n</tbody>\n</table>\n<p><strong>Think baked beans are British? They are now! We use only British-grown fava beans - Britain's original bean, grown here since the Iron Age. Our Baked British Beans are deliciously different, with large meaty fava beans in a tasty tomato sauce.</strong></p>\n<p><strong><a title=\"What are fava beans? Aren't they just broad beans?\" href=\"/blogs/news/what-are-fava-beans-are-they-just-broad-beans\" data-mce-fragment=\"1\" data-mce-href=\"/blogs/news/what-are-fava-beans-are-they-just-broad-beans\">What are fava beans? Find out here...</a></strong></p>\n<!-- split --><h3>Complete Product Details</h3><p>Our Baked British Beans are cooked and ready to eat, hot or cold. They're good served on toast but also delicious added to stews, curries or casseroles. Or even in a pie.</p>\n<h5 class=\"product-detail-title\">Cooking instructions</h5>\n<p><strong>Cooking on the Hob</strong><br>Empty contents into saucepan. Heat gently for 4-5 minutes while stirring. For best flavour do not boil or overcook. Do not reheat.</p>\n<p><strong>Microwave Cooking</strong><br>Empty contents into a non-metallic bowl and cover. Heat for 2 to 3 minutes, stirring halfway. Check the food is hot, stir well and serve. Do not reheat.</p>\n<h5 class=\"product-detail-title\">To Store</h5>\n<p>Store in a cool, dry place. Once opened, transfer contents to a non-metallic container, cover refrigerate and use with 2 days.</p>\n<h5 class=\"product-detail-title\">Ingredients</h5>\n<p>Fava Beans (Broad Beans) (42%), Water, Tomato Puree, Sugar, Modified Maize Starch, Salt, Herbs &amp; Spices, Concentrated Lemon Juice</p>\n<h5 class=\"product-detail-title\">Allergy information</h5>\n<p>No Allergens</p>\n<table width=\"100%\">\n<tbody>\n<tr>\n<td><strong>Typical values</strong></td>\n<td><strong>Per 100g</strong></td>\n</tr>\n<tr>\n<td>Energy</td>\n<td>292kJ (69kcal)</td>\n</tr>\n<tr>\n<td>Fat</td>\n<td>0.4g</td>\n</tr>\n<tr>\n<td>of which saturates</td>\n<td>0.1g</td>\n</tr>\n<tr>\n<td>Carbohydrate</td>\n<td>10.1g</td>\n</tr>\n<tr>\n<td>of which sugars</td>\n<td>4.6g</td>\n</tr>\n<tr>\n<td>Fibre</td>\n<td>5g</td>\n</tr>\n<tr>\n<td>Protein</td>\n<td>4g</td>\n</tr>\n<tr>\n<td>Salt</td>\n<td>0.6g</td>\n</tr>\n</tbody>\n</table><h5 class=\"product-detail-title\">More</h5>\n<p>Delicious, nutritious and good for the soil, fava beans are a variety of broad bean, Vicia faba, left to ripen and dry before harvest. They’re also known as field beans, horse beans, Windsor beans or ful.</p>\n<p>Suitable for vegans and vegetarians</p>\n","dfc-b:hasQuantity":"_:b263996","dfc-b:image":"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Pack-Can-Baked-Beans-1800x6_983x656_513758e6-2616-4687-a8b2-ba6dde864923.jpg?v=1677760778","dfc-b:name":"Baked British Beans - Case, 12 x 400g (can)","dfc-b:referencedBy":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466500403/CatalogItem"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466500403/CatalogItem","@type":"dfc-b:CatalogItem","dfc-b:offeredThrough":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466500403/Offer","dfc-b:sku":"NCBB/CD","dfc-b:stockLimitation":"-1"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466500403/Offer","@type":"dfc-b:Offer","dfc-b:hasPrice":{"@id":"_:b263997"}},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519467188531","@type":"dfc-b:SuppliedProduct","dfc-b:description":"<p><strong>Camelina, also known as Gold of Pleasure, has been grown in England for thousands of years for its tasty seeds and oil. Sprinkle on salads, use in baking, add to smoothies, or use as a vegan egg replacement. </strong></p>\n<!-- split --><h3>Complete Product Details</h3><p>Sprinkle on salads, add to smoothies, use in baking.</p>\n<h5 class=\"product-detail-title\">Cooking instructions</h5>\n<p>Soak 1 tablespoon of seeds in 3 tablespoons of warm water for 30 minutes to replace one egg in vegan baking.</p>\n<h5 class=\"product-detail-title\">Ingredients</h5>\n<p>Camelina seeds</p>\n<h5 class=\"product-detail-title\">Allergy information</h5>\n<p>No Allergens</p>\n<table width=\"100%\">\n<tbody>\n<tr>\n<td><strong>Typical values</strong></td>\n<td><strong>Per 100g</strong></td>\n</tr>\n<tr>\n<td>Energy</td>\n<td>1439kJ (346kcal)</td>\n</tr>\n<tr>\n<td>Fat</td>\n<td>12.1g</td>\n</tr>\n<tr>\n<td>of which saturates</td>\n<td>1.7g</td>\n</tr>\n<tr>\n<td>Carbohydrate</td>\n<td>16.4g</td>\n</tr>\n<tr>\n<td>of which sugars</td>\n<td>1.2g</td>\n</tr>\n<tr>\n<td>Fibre</td>\n<td>35.1g</td>\n</tr>\n<tr>\n<td>Protein</td>\n<td>25.4g</td>\n</tr>\n<tr>\n<td>Salt</td>\n<td>0g</td>\n</tr>\n</tbody>\n</table><p>Camelina Seeds are high in protein, a good source of Omega 3 oils and rich in antioxidants such as vitamin E</p><h5 class=\"product-detail-title\">More</h5>\n<p>Grown by Peter Fairs in Essex and Andy Howard in Kent.</p>","dfc-b:hasQuantity":"_:b263990","dfc-b:image":"https://cdn.shopify.com/s/files/1/0731/8483/7939/files/37-cammalina-fron.jpg?v=1706881950","dfc-b:name":"Camelina Seed - Retail pack, 300g","dfc-b:referencedBy":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519467188531/CatalogItem"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519467188531/AsPlannedConsumptionFlow","@type":"dfc-b:AsPlannedConsumptionFlow","dfc-b:consumes":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519467188531","dfc-b:hasQuantity":"_:b264006"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519467188531/AsPlannedProductionFlow","@type":"dfc-b:AsPlannedProductionFlow","dfc-b:hasQuantity":"_:b264007","dfc-b:produces":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519467221299"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519467188531/AsPlannedTransformation","@type":"dfc-b:AsPlannedTransformation","dfc-b:hasIncome":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519467188531/AsPlannedConsumptionFlow","dfc-b:hasOutcome":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519467188531/AsPlannedProductionFlow"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519467188531/CatalogItem","@type":"dfc-b:CatalogItem","dfc-b:offeredThrough":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519467188531/Offer","dfc-b:sku":"NGCS/R3","dfc-b:stockLimitation":"-1"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519467188531/Offer","@type":"dfc-b:Offer","dfc-b:hasPrice":{"@id":"_:b263991"}},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519467221299","@type":"dfc-b:SuppliedProduct","dfc-b:description":"<p><strong>Camelina, also known as Gold of Pleasure, has been grown in England for thousands of years for its tasty seeds and oil. Sprinkle on salads, use in baking, add to smoothies, or use as a vegan egg replacement. </strong></p>\n<!-- split --><h3>Complete Product Details</h3><p>Sprinkle on salads, add to smoothies, use in baking.</p>\n<h5 class=\"product-detail-title\">Cooking instructions</h5>\n<p>Soak 1 tablespoon of seeds in 3 tablespoons of warm water for 30 minutes to replace one egg in vegan baking.</p>\n<h5 class=\"product-detail-title\">Ingredients</h5>\n<p>Camelina seeds</p>\n<h5 class=\"product-detail-title\">Allergy information</h5>\n<p>No Allergens</p>\n<table width=\"100%\">\n<tbody>\n<tr>\n<td><strong>Typical values</strong></td>\n<td><strong>Per 100g</strong></td>\n</tr>\n<tr>\n<td>Energy</td>\n<td>1439kJ (346kcal)</td>\n</tr>\n<tr>\n<td>Fat</td>\n<td>12.1g</td>\n</tr>\n<tr>\n<td>of which saturates</td>\n<td>1.7g</td>\n</tr>\n<tr>\n<td>Carbohydrate</td>\n<td>16.4g</td>\n</tr>\n<tr>\n<td>of which sugars</td>\n<td>1.2g</td>\n</tr>\n<tr>\n<td>Fibre</td>\n<td>35.1g</td>\n</tr>\n<tr>\n<td>Protein</td>\n<td>25.4g</td>\n</tr>\n<tr>\n<td>Salt</td>\n<td>0g</td>\n</tr>\n</tbody>\n</table><p>Camelina Seeds are high in protein, a good source of Omega 3 oils and rich in antioxidants such as vitamin E</p><h5 class=\"product-detail-title\">More</h5>\n<p>Grown by Peter Fairs in Essex and Andy Howard in Kent.</p>","dfc-b:hasQuantity":"_:b263998","dfc-b:image":"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Cameilna-Seeds-1800x1200_8c00a108-d8f7-4920-9bac-758a2c6a8b56.jpg?v=1677760797","dfc-b:name":"Camelina Seed - Case, 8 x 300g","dfc-b:referencedBy":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519467221299/CatalogItem"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519467221299/CatalogItem","@type":"dfc-b:CatalogItem","dfc-b:offeredThrough":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519467221299/Offer","dfc-b:sku":"NGCS/C8","dfc-b:stockLimitation":"-1"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519467221299/Offer","@type":"dfc-b:Offer","dfc-b:hasPrice":{"@id":"_:b263999"}},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519470924083","@type":"dfc-b:SuppliedProduct","dfc-b:description":"<table width=\"100%\">\n<tbody>\n<tr style=\"border: 0px;\">\n<td bgcolor=\"#d6fbed\" style=\"color: #000000; border: 0px; width: 526px;\"><b>The rich, smoky and salty taste of dulse adds depth to dishes of all kinds.</b></td>\n</tr>\n</tbody>\n</table>\n<p>Eating dulse is an ancient tradition in Scots and Irish culture. It adds a wonderful depth of flavour and is rich in minerals and protein.</p>\n<p>Sometimes known as 'vegetarian bacon' it has a wonderful robust flavour that pairs well with seafood, leafy greens and tomatoes.</p>\n<p>Mara Seaweed is harvested sustainably from the pure, wild waters around Scotland and Ireland. <span>To avoid contamination, the seaweed is packed into sealed sacks before being brought up the beach and delivered fresh, directly to the factory. The seaweed is picked and processed within 24 hours to lock in flavour, ensure quality and secure maximum nutritional benefits.</span></p><h5 class=\"product-detail-title\">How to use</h5>\n<p>Dulse has a natural, lingering smoky taste. It's delicious when generously shaken on dark green vegetables and rich pulse dishes.</p>\n<p>For an extra savoury hit without the salt, use dulse flakes to season roasted vegetable, or stir into bolognese sauce or chilli before serving. Dulse is also perfect scattered mixed through crispy kale.</p>\n<p>For an unusual salted caramel-style twist, try pairing dulse with dark chocolate. Just combine a pinch of dulse with the other dry ingredients in any brownie or truffle recipe.</p>\n<h5 class=\"product-detail-title\">Ingredients</h5>\n<p>100% Dulse (<em>Palmaria palmata</em>)</p>\n<h5 class=\"product-detail-title\">Allergy information</h5>\n<p>May contain fish, crustaceans, molluscs.\n</p>\n<table width=\"100%\">\n<tbody>\n<tr>\n<td><strong>Typical values</strong></td>\n<td><strong>Per 100g</strong></td>\n</tr>\n<tr>\n<td>Energy</td>\n<td>974kJ (234kcal)</td>\n</tr>\n<tr>\n<td>Fat</td>\n<td>\n<p>1.5g</p>\n</td>\n</tr>\n<tr>\n<td>of which saturates</td>\n<td>0.4g</td>\n</tr>\n<tr>\n<td>Carbohydrate</td>\n<td>22.8g</td>\n</tr>\n<tr>\n<td>of which sugars</td>\n<td>1.0g</td>\n</tr>\n<tr>\n<td>Fibre</td>\n<td>36.9g</td>\n</tr>\n<tr>\n<td>Protein</td>\n<td>13.8g</td>\n</tr>\n<tr>\n<td>Salt</td>\n<td>4.9g</td>\n</tr>\n</tbody>\n</table><h5 class=\"product-detail-title\">More</h5>\n<p>Product of Scotland<br>Great Taste award winner<br>Suitable for vegans and vegetarians<br>A source of iodine, calcium, potassium, magnesium, manganese, copper, iron, zinc</p>","dfc-b:hasQuantity":"_:b263992","dfc-b:image":"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Mara-Dulse-30g-tin-1800x1200.jpg?v=1677760832","dfc-b:name":"Dulse Flakes - Retail pouch, 30g","dfc-b:referencedBy":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519470924083/CatalogItem"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519470924083/AsPlannedConsumptionFlow","@type":"dfc-b:AsPlannedConsumptionFlow","dfc-b:consumes":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519470924083","dfc-b:hasQuantity":"_:b264008"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519470924083/AsPlannedProductionFlow","@type":"dfc-b:AsPlannedProductionFlow","dfc-b:hasQuantity":"_:b264009","dfc-b:produces":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519470956851"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519470924083/AsPlannedTransformation","@type":"dfc-b:AsPlannedTransformation","dfc-b:hasIncome":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519470924083/AsPlannedConsumptionFlow","dfc-b:hasOutcome":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519470924083/AsPlannedProductionFlow"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519470924083/CatalogItem","@type":"dfc-b:CatalogItem","dfc-b:offeredThrough":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519470924083/Offer","dfc-b:sku":"MAR/WDULS/P3","dfc-b:stockLimitation":"5"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519470924083/Offer","@type":"dfc-b:Offer","dfc-b:hasPrice":{"@id":"_:b263993"}},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519470956851","@type":"dfc-b:SuppliedProduct","dfc-b:description":"<table width=\"100%\">\n<tbody>\n<tr style=\"border: 0px;\">\n<td bgcolor=\"#d6fbed\" style=\"color: #000000; border: 0px; width: 526px;\"><b>The rich, smoky and salty taste of dulse adds depth to dishes of all kinds.</b></td>\n</tr>\n</tbody>\n</table>\n<p>Eating dulse is an ancient tradition in Scots and Irish culture. It adds a wonderful depth of flavour and is rich in minerals and protein.</p>\n<p>Sometimes known as 'vegetarian bacon' it has a wonderful robust flavour that pairs well with seafood, leafy greens and tomatoes.</p>\n<p>Mara Seaweed is harvested sustainably from the pure, wild waters around Scotland and Ireland. <span>To avoid contamination, the seaweed is packed into sealed sacks before being brought up the beach and delivered fresh, directly to the factory. The seaweed is picked and processed within 24 hours to lock in flavour, ensure quality and secure maximum nutritional benefits.</span></p><h5 class=\"product-detail-title\">How to use</h5>\n<p>Dulse has a natural, lingering smoky taste. It's delicious when generously shaken on dark green vegetables and rich pulse dishes.</p>\n<p>For an extra savoury hit without the salt, use dulse flakes to season roasted vegetable, or stir into bolognese sauce or chilli before serving. Dulse is also perfect scattered mixed through crispy kale.</p>\n<p>For an unusual salted caramel-style twist, try pairing dulse with dark chocolate. Just combine a pinch of dulse with the other dry ingredients in any brownie or truffle recipe.</p>\n<h5 class=\"product-detail-title\">Ingredients</h5>\n<p>100% Dulse (<em>Palmaria palmata</em>)</p>\n<h5 class=\"product-detail-title\">Allergy information</h5>\n<p>May contain fish, crustaceans, molluscs.\n</p>\n<table width=\"100%\">\n<tbody>\n<tr>\n<td><strong>Typical values</strong></td>\n<td><strong>Per 100g</strong></td>\n</tr>\n<tr>\n<td>Energy</td>\n<td>974kJ (234kcal)</td>\n</tr>\n<tr>\n<td>Fat</td>\n<td>\n<p>1.5g</p>\n</td>\n</tr>\n<tr>\n<td>of which saturates</td>\n<td>0.4g</td>\n</tr>\n<tr>\n<td>Carbohydrate</td>\n<td>22.8g</td>\n</tr>\n<tr>\n<td>of which sugars</td>\n<td>1.0g</td>\n</tr>\n<tr>\n<td>Fibre</td>\n<td>36.9g</td>\n</tr>\n<tr>\n<td>Protein</td>\n<td>13.8g</td>\n</tr>\n<tr>\n<td>Salt</td>\n<td>4.9g</td>\n</tr>\n</tbody>\n</table><h5 class=\"product-detail-title\">More</h5>\n<p>Product of Scotland<br>Great Taste award winner<br>Suitable for vegans and vegetarians<br>A source of iodine, calcium, potassium, magnesium, manganese, copper, iron, zinc</p>","dfc-b:hasQuantity":"_:b264000","dfc-b:image":"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Mara-Dulse-30g-tin-1800x1200.jpg?v=1677760832","dfc-b:name":"Dulse Flakes - Case, 10 x 30g","dfc-b:referencedBy":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519470956851/CatalogItem"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519470956851/CatalogItem","@type":"dfc-b:CatalogItem","dfc-b:offeredThrough":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519470956851/Offer","dfc-b:sku":"MAR/WDULS/CX","dfc-b:stockLimitation":"2"},{"@id":"https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519470956851/Offer","@type":"dfc-b:Offer","dfc-b:hasPrice":{"@id":"_:b264001"}}]} + recorded_at: Wed, 26 Feb 2025 04:26:41 GMT +recorded_with: VCR 6.2.0 diff --git a/spec/jobs/open_order_cycle_job_spec.rb b/spec/jobs/open_order_cycle_job_spec.rb new file mode 100644 index 00000000000..0e57542389e --- /dev/null +++ b/spec/jobs/open_order_cycle_job_spec.rb @@ -0,0 +1,97 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe OpenOrderCycleJob do + let(:now){ Time.zone.now } + let(:order_cycle) { create(:simple_order_cycle, orders_open_at: now) } + subject { OpenOrderCycleJob.perform_now(order_cycle.id) } + + around do |example| + Timecop.freeze(now) { example.run } + end + + it "marks as open" do + expect { + subject + order_cycle.reload + } + .to change { order_cycle.opened_at } + + expect(order_cycle.opened_at).to be_within(1).of(now) + end + + it "enqueues webhook job" do + expect(OrderCycles::WebhookService) + .to receive(:create_webhook_job).with(order_cycle, 'order_cycle.opened', now).once + + subject + end + + describe "syncing remote products" do + let!(:user) { create(:testdfc_user, owned_enterprises: [enterprise]) } + + let(:enterprise) { create(:supplier_enterprise) } + let!(:variant) { create(:variant, name: "Sauce", supplier_id: enterprise.id) } + let!(:order_cycle) { + create(:simple_order_cycle, orders_open_at: now, + suppliers: [enterprise], variants: [variant]) + } + + it "synchronises products from a FDC catalog", vcr: true do + user.update!(oidc_account: build(:testdfc_account)) + # One product is existing in OFN + product_id = + "https://env-0105831.jcloud-ver-jpe.ik-server.com/api/dfc/Enterprises/test-hodmedod/SuppliedProducts/44519466467635" + variant.semantic_links << SemanticLink.new(semantic_id: product_id) + + expect { + subject + variant.reload + order_cycle.reload + }.to change { order_cycle.opened_at } + .and change { enterprise.supplied_products.count }.by(0) # It shouldn't add, only update + .and change { variant.display_name } + .and change { variant.unit_value } + # 18.85 wholesale variant price divided by 12 cans in the slab. + .and change { variant.price }.to(1.57) + .and change { variant.on_demand }.to(true) + .and change { variant.on_hand }.by(0) + .and query_database 46 + end + end + + describe "concurrency", concurrency: true do + let(:breakpoint) { Mutex.new } + + it "doesn't open order cycle twice" do + # Pause jobs when placing new job: + breakpoint.lock + allow(OpenOrderCycleJob).to( + receive(:new).and_wrap_original do |method, *args| + breakpoint.synchronize {} # rubocop:disable Lint/EmptyBlock + method.call(*args) + end + ) + + expect(OrderCycles::WebhookService) + .to receive(:create_webhook_job).with(order_cycle, 'order_cycle.opened', now).once + + expect{ + # Start two jobs in parallel: + threads = [ + Thread.new { OpenOrderCycleJob.perform_now(order_cycle.id) }, + Thread.new { OpenOrderCycleJob.perform_now(order_cycle.id) }, + ] + + # Wait for both to jobs to pause. + # This can reveal a race condition. + sleep 0.1 + + # Resume and complete both jobs: + breakpoint.unlock + threads.each(&:join) + }.to raise_error ActiveRecord::RecordNotFound + end + end +end diff --git a/spec/jobs/order_cycle_opened_job_spec.rb b/spec/jobs/order_cycle_opened_job_spec.rb deleted file mode 100644 index caf5ee6ef10..00000000000 --- a/spec/jobs/order_cycle_opened_job_spec.rb +++ /dev/null @@ -1,62 +0,0 @@ -# frozen_string_literal: true - -require 'spec_helper' - -RSpec.describe OrderCycleOpenedJob do - let(:oc_opened_before) { - create(:order_cycle, orders_open_at: 1.hour.ago) - } - let(:oc_opened_now) { - create(:order_cycle, orders_open_at: Time.zone.now) - } - let(:oc_opening_soon) { - create(:order_cycle, orders_open_at: 1.minute.from_now) - } - - it "enqueues jobs for recently opened order cycles only" do - expect(OrderCycles::WebhookService) - .to receive(:create_webhook_job).with(oc_opened_now, 'order_cycle.opened') - - expect(OrderCycles::WebhookService) - .not_to receive(:create_webhook_job).with(oc_opened_before, 'order_cycle.opened') - - expect(OrderCycles::WebhookService) - .not_to receive(:create_webhook_job).with(oc_opening_soon, 'order_cycle.opened') - - OrderCycleOpenedJob.perform_now - end - - describe "concurrency", concurrency: true do - let(:breakpoint) { Mutex.new } - - it "doesn't place duplicate job when run concurrently" do - oc_opened_now - - # Pause jobs when placing new job: - breakpoint.lock - allow(OrderCycleOpenedJob).to( - receive(:new).and_wrap_original do |method, *args| - breakpoint.synchronize {} - method.call(*args) - end - ) - - expect(OrderCycles::WebhookService) - .to receive(:create_webhook_job).with(oc_opened_now, 'order_cycle.opened').once - - # Start two jobs in parallel: - threads = [ - Thread.new { OrderCycleOpenedJob.perform_now }, - Thread.new { OrderCycleOpenedJob.perform_now }, - ] - - # Wait for both to jobs to pause. - # This can reveal a race condition. - sleep 0.1 - - # Resume and complete both jobs: - breakpoint.unlock - threads.each(&:join) - end - end -end diff --git a/spec/jobs/trigger_order_cycles_to_open_job_spec.rb b/spec/jobs/trigger_order_cycles_to_open_job_spec.rb new file mode 100644 index 00000000000..9b272025031 --- /dev/null +++ b/spec/jobs/trigger_order_cycles_to_open_job_spec.rb @@ -0,0 +1,22 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe TriggerOrderCyclesToOpenJob do + let(:oc_opened_before) { + create(:simple_order_cycle, orders_open_at: 1.hour.ago) + } + let(:oc_opened_now) { + create(:simple_order_cycle, orders_open_at: Time.zone.now) + } + let(:oc_opening_soon) { + create(:simple_order_cycle, orders_open_at: 1.minute.from_now) + } + + it "enqueues jobs for recently opened order cycles only" do + expect{ TriggerOrderCyclesToOpenJob.perform_now } + .to enqueue_job(OpenOrderCycleJob).with(oc_opened_now.id) + .and enqueue_job(OpenOrderCycleJob).with(oc_opened_before.id).exactly(0).times + .and enqueue_job(OpenOrderCycleJob).with(oc_opening_soon.id).exactly(0).times + end +end diff --git a/spec/jobs/webhook_delivery_job_spec.rb b/spec/jobs/webhook_delivery_job_spec.rb index 0b09ed7bde5..5383f5e87c4 100644 --- a/spec/jobs/webhook_delivery_job_spec.rb +++ b/spec/jobs/webhook_delivery_job_spec.rb @@ -3,9 +3,10 @@ require 'spec_helper' RSpec.describe WebhookDeliveryJob do - subject { WebhookDeliveryJob.new(url, event, data) } + subject { WebhookDeliveryJob.new(url, event, data, at:) } let(:url) { 'https://test/endpoint' } let(:event) { 'order_cycle.opened' } + let(:at) { 1.second.ago } let(:data) { { order_cycle_id: 123, name: "Order cycle 1", open_at: 1.minute.ago.to_s, tags: ["tag1", "tag2"] @@ -25,7 +26,7 @@ Timecop.freeze do expected_body = { id: /.+/, - at: Time.zone.now.to_s, + at: at.to_s, event:, data:, } diff --git a/spec/services/order_cycles/webhook_service_spec.rb b/spec/services/order_cycles/webhook_service_spec.rb index bdc77bb151f..73fe341f83f 100644 --- a/spec/services/order_cycles/webhook_service_spec.rb +++ b/spec/services/order_cycles/webhook_service_spec.rb @@ -8,11 +8,14 @@ :simple_order_cycle, name: "Order cycle 1", orders_open_at: "2022-09-19 09:00:00".to_time, + opened_at: "2022-09-19 09:00:01".to_time, orders_close_at: "2022-09-19 17:00:00".to_time, coordinator:, ) } let(:coordinator) { create :distributor_enterprise, name: "Starship Enterprise" } + let(:at) { "2022-09-19 09:00:02".to_time } + subject { OrderCycles::WebhookService.create_webhook_job(order_cycle, "order_cycle.opened", at) } describe "creating payloads" do it "doesn't create webhook payload for enterprise users" do @@ -21,7 +24,7 @@ coordinator_user = create(:user, enterprises: [coordinator]) coordinator_user.webhook_endpoints.create!(url: "http://coordinator_user_url") - expect{ OrderCycles::WebhookService.create_webhook_job(order_cycle, "order_cycle.opened") } + expect{ subject } .not_to enqueue_job(WebhookDeliveryJob).with("http://coordinator_user_url", any_args) end @@ -31,7 +34,7 @@ end it "creates webhook payload for order cycle coordinator" do - expect{ OrderCycles::WebhookService.create_webhook_job(order_cycle, "order_cycle.opened") } + expect{ subject } .to enqueue_job(WebhookDeliveryJob).with("http://coordinator_owner_url", any_args) end @@ -43,20 +46,21 @@ id: order_cycle.id, name: "Order cycle 1", orders_open_at: "2022-09-19 09:00:00".to_time, + opened_at: "2022-09-19 09:00:01".to_time, orders_close_at: "2022-09-19 17:00:00".to_time, coordinator_id: coordinator.id, coordinator_name: "Starship Enterprise", } - expect{ OrderCycles::WebhookService.create_webhook_job(order_cycle, "order_cycle.opened") } + expect{ subject } .to enqueue_job(WebhookDeliveryJob).exactly(1).times - .with("http://coordinator_owner_url", "order_cycle.opened", hash_including(data)) + .with("http://coordinator_owner_url", "order_cycle.opened", hash_including(data), at:) end end context "coordinator owner doesn't have endpoint configured" do it "doesn't create webhook payload" do - expect{ OrderCycles::WebhookService.create_webhook_job(order_cycle, "order_cycle.opened") } + expect{ subject } .not_to enqueue_job(WebhookDeliveryJob) end end @@ -84,13 +88,13 @@ coordinator_name: "Starship Enterprise", } - expect{ - OrderCycles::WebhookService.create_webhook_job(order_cycle, "order_cycle.opened") - } + expect{ subject } .to enqueue_job(WebhookDeliveryJob).with("http://distributor1_owner_url", - "order_cycle.opened", hash_including(data)) + "order_cycle.opened", hash_including(data), + at:) .and enqueue_job(WebhookDeliveryJob).with("http://distributor2_owner_url", - "order_cycle.opened", hash_including(data)) + "order_cycle.opened", hash_including(data), + at:) end end @@ -107,9 +111,7 @@ it "creates only one webhook payload for the user's endpoint" do user.webhook_endpoints.create! url: "http://coordinator_owner_url" - expect{ - OrderCycles::WebhookService.create_webhook_job(order_cycle, "order_cycle.opened") - } + expect{ subject } .to enqueue_job(WebhookDeliveryJob).with("http://coordinator_owner_url", any_args) end end @@ -131,9 +133,7 @@ } it "doesn't create a webhook payload for supplier owner" do - expect{ - OrderCycles::WebhookService.create_webhook_job(order_cycle, "order_cycle.opened") - } + expect{ subject } .not_to enqueue_job(WebhookDeliveryJob).with("http://supplier_owner_url", any_args) end end @@ -142,7 +142,7 @@ context "without webhook subscribed to enterprise" do it "doesn't create webhook payload" do - expect{ OrderCycles::WebhookService.create_webhook_job(order_cycle, "order_cycle.opened") } + expect{ subject } .not_to enqueue_job(WebhookDeliveryJob) end end