wekan/tests/wekanCreator.import.test.js

/**
 * Test: WekanCreator import with swimlane preservation
 *
 * Simulates exporting a board with swimlanes and importing it back,
 * verifying that:
 * 1. Swimlanes are correctly mapped from old IDs to new IDs
 * 2. Cards reference the correct swimlane IDs after import
 * 3. A default swimlane is created when no swimlanes exist
 * 4. ID normalization (id → _id) works for all exported items
 */

// Mock data: exported board with swimlanes and cards
const mockExportedBoard = {
  _format: 'wekan-board-1.0.0',
  _id: 'board1',
  title: 'Test Board',
  archived: false,
  color: 'bgnone',
  permission: 'private',
  createdAt: new Date().toISOString(),
  modifiedAt: new Date().toISOString(),
  members: [
    {
      userId: 'user1',
      wekanId: 'user1',
      isActive: true,
      isAdmin: true,
    },
  ],
  labels: [],
  swimlanes: [
    {
      _id: 'swimlane1',
      title: 'Swimlane 1',
      archived: false,
      sort: 0,
    },
    {
      _id: 'swimlane2',
      title: 'Swimlane 2',
      archived: false,
      sort: 1,
    },
  ],
  lists: [
    {
      _id: 'list1',
      title: 'To Do',
      archived: false,
      sort: 0,
    },
    {
      _id: 'list2',
      title: 'Done',
      archived: false,
      sort: 1,
    },
  ],
  cards: [
    {
      _id: 'card1',
      title: 'Card in swimlane 1',
      archived: false,
      swimlaneId: 'swimlane1',
      listId: 'list1',
      sort: 0,
      description: 'Test card',
      dateLastActivity: new Date().toISOString(),
      labelIds: [],
    },
    {
      _id: 'card2',
      title: 'Card in swimlane 2',
      archived: false,
      swimlaneId: 'swimlane2',
      listId: 'list2',
      sort: 0,
      description: 'Another test card',
      dateLastActivity: new Date().toISOString(),
      labelIds: [],
    },
  ],
  comments: [],
  activities: [
    {
      activityType: 'createBoard',
      createdAt: new Date().toISOString(),
      userId: 'user1',
    },
  ],
  checklists: [],
  checklistItems: [],
  subtaskItems: [],
  customFields: [],
  rules: [],
  triggers: [],
  actions: [],
  users: [
    {
      _id: 'user1',
      username: 'admin',
      profile: {
        fullname: 'Admin User',
      },
    },
  ],
};

// Export format variation: using 'id' instead of '_id'
const mockExportedBoardWithIdField = {
  ...mockExportedBoard,
  swimlanes: [
    {
      id: 'swimlane1',
      title: 'Swimlane 1 (id variant)',
      archived: false,
      sort: 0,
    },
  ],
  lists: [
    {
      id: 'list1',
      title: 'To Do (id variant)',
      archived: false,
      sort: 0,
    },
  ],
  cards: [
    {
      id: 'card1',
      title: 'Card (id variant)',
      archived: false,
      swimlaneId: 'swimlane1',
      listId: 'list1',
      sort: 0,
      description: 'Test card with id field',
      dateLastActivity: new Date().toISOString(),
      labelIds: [],
    },
  ],
};

// Test: Verify id → _id normalization
function testIdNormalization() {
  console.log('\n=== Test: ID Normalization (id → _id) ===');

  // Simulate the normalization logic from WekanCreator constructor
  const normalizeIds = arr => {
    if (!arr) return;
    arr.forEach(item => {
      if (item && item.id && !item._id) {
        item._id = item.id;
      }
    });
  };

  const testData = {
    lists: mockExportedBoardWithIdField.lists,
    cards: mockExportedBoardWithIdField.cards,
    swimlanes: mockExportedBoardWithIdField.swimlanes,
  };

  normalizeIds(testData.lists);
  normalizeIds(testData.cards);
  normalizeIds(testData.swimlanes);

  // Check results
  if (testData.swimlanes[0]._id === 'swimlane1') {
    console.log('✓ Swimlane: id → _id normalization created _id');
  } else {
    console.log('✗ Swimlane: id → _id normalization FAILED');
  }

  if (testData.lists[0]._id === 'list1') {
    console.log('✓ List: id → _id normalization created _id');
  } else {
    console.log('✗ List: id → _id normalization FAILED');
  }

  if (testData.cards[0]._id === 'card1') {
    console.log('✓ Card: id → _id normalization created _id');
  } else {
    console.log('✗ Card: id → _id normalization FAILED');
  }
}

// Test: Verify swimlane mapping during import
function testSwimlaneMapping() {
  console.log('\n=== Test: Swimlane Mapping (export → import) ===');

  // Simulate WekanCreator swimlane mapping
  const swimlanes = {};
  const swimlaneIndexMap = {}; // Track old → new ID mappings

  // Simulate createSwimlanes: build mapping of old ID → new ID
  mockExportedBoard.swimlanes.forEach((swimlane, index) => {
    const oldId = swimlane._id;
    const newId = `new_swimlane_${index}`; // Simulated new ID
    swimlanes[oldId] = newId;
    swimlaneIndexMap[oldId] = newId;
  });

  console.log(`✓ Created mapping for ${Object.keys(swimlanes).length} swimlanes:`);
  Object.entries(swimlanes).forEach(([oldId, newId]) => {
    console.log(`  ${oldId} → ${newId}`);
  });

  // Simulate createCards: cards reference swimlanes using mapping
  const cardSwimlaneCheck = mockExportedBoard.cards.every(card => {
    const oldSwimlaneId = card.swimlaneId;
    const newSwimlaneId = swimlanes[oldSwimlaneId];
    return newSwimlaneId !== undefined;
  });

  if (cardSwimlaneCheck) {
    console.log('✓ All cards can be mapped to swimlanes');
  } else {
    console.log('✗ Some cards have missing swimlane mappings');
  }
}

// Test: Verify default swimlane creation when none exist
function testDefaultSwimlaneCreation() {
  console.log('\n=== Test: Default Swimlane Creation ===');

  const boardWithoutSwimlanes = {
    ...mockExportedBoard,
    swimlanes: [],
  };

  // Simulate the default swimlane logic from WekanCreator
  let swimlanes = {};
  let defaultSwimlaneId = null;

  // If no swimlanes were provided, create a default
  if (!swimlanes || Object.keys(swimlanes).length === 0) {
    defaultSwimlaneId = 'new_default_swimlane';
    console.log('✓ Default swimlane created:', defaultSwimlaneId);
  }

  // Verify cards without swimlane references use the default
  const cardsWithoutSwimlane = boardWithoutSwimlanes.cards.filter(c => !c.swimlaneId);
  if (cardsWithoutSwimlane.length > 0 && defaultSwimlaneId) {
    console.log(`✓ ${cardsWithoutSwimlane.length} cards will use default swimlane`);
  } else if (cardsWithoutSwimlane.length === 0) {
    console.log('✓ No cards lacking swimlane (test data all have swimlaneId)');
  }
}

// Test: Verify swimlane + card integrity after full import cycle
function testFullImportCycle() {
  console.log('\n=== Test: Full Import Cycle ===');

  // Step 1: Normalize IDs
  const normalizeIds = arr => {
    if (!arr) return;
    arr.forEach(item => {
      if (item && item.id && !item._id) {
        item._id = item.id;
      }
    });
  };

  const data = JSON.parse(JSON.stringify(mockExportedBoard)); // Deep copy
  normalizeIds(data.swimlanes);
  normalizeIds(data.lists);
  normalizeIds(data.cards);

  // Step 2: Map swimlanes
  const swimlaneMap = {};
  data.swimlanes.forEach((s, idx) => {
    swimlaneMap[s._id] = `imported_swimlane_${idx}`;
  });

  // Step 3: Verify cards get mapped swimlane IDs
  let unmappedCards = 0;
  data.cards.forEach(card => {
    if (card.swimlaneId && !swimlaneMap[card.swimlaneId]) {
      unmappedCards++;
    }
  });

  if (unmappedCards === 0) {
    console.log('✓ All cards have valid swimlane references');
  } else {
    console.log(`✗ ${unmappedCards} cards have unmapped swimlane references`);
  }

  if (data.swimlanes.length > 0) {
    console.log(`✓ ${data.swimlanes.length} swimlanes preserved in import`);
  }

  if (data.cards.length > 0) {
    console.log(`✓ ${data.cards.length} cards preserved in import`);
  }
}

// Run all tests
if (typeof describe === 'undefined') {
  // Running in Node.js or standalone (not Mocha)
  console.log('====================================');
  console.log('WekanCreator Import Tests');
  console.log('====================================');

  testIdNormalization();
  testSwimlaneMapping();
  testDefaultSwimlaneCreation();
  testFullImportCycle();

  console.log('\n====================================');
  console.log('Tests completed');
  console.log('====================================\n');
}