feat: make local development the default

plugins/plugin-tools/src/config.spec.ts

@@ -75,6 +75,39 @@ describe('config', () => {
         })
       ).toBe(true);
     });
+
+    it('returns true if container is undefined and mode is development', () => {
+      expect(useDockerContainer({params: {}, mode: 'development'})).toBe(true);
+    });
+
+    it('returns false if container is undefined and mode is production', () => {
+      expect(useDockerContainer({params: {}, mode: 'production'})).toBe(false);
+    });
+
+    it('returns true if params is undefined and mode is development', () => {
+      expect(useDockerContainer({params: undefined, mode: 'development'})).toBe(true);
+    });
+
+    it('returns false if params is undefined and mode is production', () => {
+      expect(useDockerContainer({params: undefined, mode: 'production'})).toBe(false);
+    });
+
+    it('returns true if container is an empty object and mode is development', () => {
+      expect(useDockerContainer({params: {container: {}}, mode: 'development'})).toBe(true);
+    });
+
+    it('returns false if container has empty modes[]', () => {
+      expect(
+        useDockerContainer({
+          params: {
+            container: {
+              modes: []
+            }
+          },
+          mode: 'development'
+        })
+      ).toBe(false);
+    });
   });
 
   describe('satelliteId', () => {

plugins/plugin-tools/src/config.ts

@@ -15,9 +15,8 @@ import {JunoPluginError} from './error';
 import type {ConfigArgs, IcpIds, JunoParams} from './types';
 
 export const useDockerContainer = ({params, mode}: ConfigArgs): boolean =>
-  params?.container !== undefined &&
   params?.container !== false &&
-  (params?.container === true
+  (params?.container === undefined || params?.container === true
     ? mode === 'development'
     : (params?.container?.modes ?? ['development']).includes(mode));
 

plugins/plugin-tools/src/init.spec.ts

@@ -17,78 +17,114 @@ vi.mock('@junobuild/config-loader', async () => {
 });
 
 describe('init', () => {
-  describe('initConfig (with config-loader mocks)', () => {
-    const args: ConfigArgs = {
+  const args: ConfigArgs = {
+    params: {},
+    mode: 'production'
+  };
+
+  let spyJunoConfigExist: MockInstance;
+  let spyReadJunoConfig: MockInstance;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    spyJunoConfigExist = vi.spyOn(configLoader, 'junoConfigExist').mockResolvedValue(true);
+    spyReadJunoConfig = vi.spyOn(configLoader, 'readJunoConfig').mockResolvedValue({
+      satellite: {ids: {production: 'mock-satellite-id'}},
+      orbiter: {id: 'mock-orbiter-id'}
+    });
+  });
+
+  it('returns config for development', async () => {
+    const result = await initConfig({
       params: {},
       mode: 'development'
-    };
+    });
 
-    let spyJunoConfigExist: MockInstance;
-    let spyReadJunoConfig: MockInstance;
+    expect(result).toEqual({
+      orbiterId: undefined,
+      satelliteId: 'jx5yt-yyaaa-aaaal-abzbq-cai',
+      icpIds: {
+        internetIdentityId: 'rdmx6-jaaaa-aaaaa-aaadq-cai',
+        icpLedgerId: 'ryjl3-tyaaa-aaaaa-aaaba-cai',
+        icpIndexId: 'qhbym-qaaaa-aaaaa-aaafq-cai'
+      },
+      container: 'http://127.0.0.1:5987'
+    });
 
-    beforeEach(() => {
-      vi.clearAllMocks();
+    expect(spyJunoConfigExist).not.toHaveBeenCalled();
+    expect(spyReadJunoConfig).not.toHaveBeenCalled();
+  });
 
-      spyJunoConfigExist = vi.spyOn(configLoader, 'junoConfigExist').mockResolvedValue(true);
-      spyReadJunoConfig = vi.spyOn(configLoader, 'readJunoConfig').mockResolvedValue({
-        satellite: {ids: {development: 'mock-satellite-id'}},
-        orbiter: {id: 'mock-orbiter-id'}
-      });
+  it('returns config without container for production', async () => {
+    const result = await initConfig(args);
+
+    expect(result).toEqual({
+      satelliteId: 'mock-satellite-id',
+      orbiterId: 'mock-orbiter-id',
+      icpIds: {
+        internetIdentityId: 'rdmx6-jaaaa-aaaaa-aaadq-cai',
+        icpLedgerId: 'ryjl3-tyaaa-aaaaa-aaaba-cai',
+        icpIndexId: 'qhbym-qaaaa-aaaaa-aaafq-cai'
+      },
+      container: undefined
     });
 
-    it('returns config when not using Docker container', async () => {
-      const result = await initConfig(args);
+    expect(spyJunoConfigExist).toHaveBeenCalled();
+    expect(spyReadJunoConfig).toHaveBeenCalled();
+  });
 
-      expect(result).toEqual({
-        satelliteId: 'mock-satellite-id',
-        orbiterId: 'mock-orbiter-id',
-        icpIds: {
-          internetIdentityId: 'rdmx6-jaaaa-aaaaa-aaadq-cai',
-          icpLedgerId: 'ryjl3-tyaaa-aaaaa-aaaba-cai',
-          icpIndexId: 'qhbym-qaaaa-aaaaa-aaafq-cai'
-        },
-        container: undefined
-      });
+  it('skips assertJunoConfig when using Docker container', async () => {
+    const dockerArgs: ConfigArgs = {
+      params: {container: true},
+      mode: 'development'
+    };
 
-      expect(spyJunoConfigExist).toHaveBeenCalled();
-      expect(spyReadJunoConfig).toHaveBeenCalled();
+    const result = await initConfig(dockerArgs);
+
+    expect(result).toEqual({
+      satelliteId: 'jx5yt-yyaaa-aaaal-abzbq-cai', // fallback to docker const
+      orbiterId: undefined,
+      icpIds: {
+        internetIdentityId: 'rdmx6-jaaaa-aaaaa-aaadq-cai',
+        icpLedgerId: 'ryjl3-tyaaa-aaaaa-aaaba-cai',
+        icpIndexId: 'qhbym-qaaaa-aaaaa-aaafq-cai'
+      },
+      container: 'http://127.0.0.1:5987'
     });
 
-    it('skips assertJunoConfig when using Docker container', async () => {
-      const dockerArgs: ConfigArgs = {
-        params: {container: true},
-        mode: 'development'
-      };
-
-      const result = await initConfig(dockerArgs);
+    expect(spyJunoConfigExist).not.toHaveBeenCalled();
+    expect(spyReadJunoConfig).not.toHaveBeenCalled();
+  });
 
-      expect(result).toEqual({
-        satelliteId: 'jx5yt-yyaaa-aaaal-abzbq-cai', // fallback to docker const
-        orbiterId: undefined,
-        icpIds: {
-          internetIdentityId: 'rdmx6-jaaaa-aaaaa-aaadq-cai',
-          icpLedgerId: 'ryjl3-tyaaa-aaaaa-aaaba-cai',
-          icpIndexId: 'qhbym-qaaaa-aaaaa-aaafq-cai'
-        },
-        container: 'http://127.0.0.1:5987'
-      });
+  it('throws if config does not exist and mode is production', async () => {
+    vi.spyOn(configLoader, 'junoConfigExist').mockResolvedValue(false);
 
-      expect(spyJunoConfigExist).not.toHaveBeenCalled();
-      expect(spyReadJunoConfig).not.toHaveBeenCalled();
-    });
+    await expect(initConfig(args)).rejects.toThrow(/No Juno configuration found/);
+  });
 
-    it('throws if config does not exist', async () => {
-      vi.spyOn(configLoader, 'junoConfigExist').mockResolvedValue(false);
+  it('throws if satelliteId is missing in config if container is set to false', async () => {
+    vi.spyOn(configLoader, 'readJunoConfig').mockResolvedValueOnce({
+      satellite: {}
+    } as unknown as JunoConfig);
 
-      await expect(initConfig(args)).rejects.toThrow(/No Juno configuration found/);
-    });
+    await expect(
+      initConfig({
+        params: {
+          container: false
+        },
+        mode: 'development'
+      })
+    ).rejects.toThrow(/A satellite ID for development must be set/);
+  });
 
-    it('throws if satelliteId is missing in config', async () => {
-      vi.spyOn(configLoader, 'readJunoConfig').mockResolvedValueOnce({
-        satellite: {}
-      } as unknown as JunoConfig);
+  it('throws if satelliteId is missing in config', async () => {
+    vi.spyOn(configLoader, 'readJunoConfig').mockResolvedValueOnce({
+      satellite: {}
+    } as unknown as JunoConfig);
 
-      await expect(initConfig(args)).rejects.toThrow(/A satellite ID for development must be set/);
-    });
+    await expect(initConfig(args)).rejects.toThrow(
+      /Your configuration is invalid. A satellite ID for production must be set in your configuration file./
+    );
   });
 });