limj
2023-10-24 93652435728de839582440eefd5122c281181d35
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
/**
 * @file        ADSO-9341
 * @description Scenario analysis - bottleneck resources view, filtering on selection in the Navigation panel
 * @author      CHEAH Meng Yew (MengYew.CHEAH@3ds.com)
 * @copyright   Dassault Systemes
 */
 import { qCustomMatcher } from '../../e2elib/lib/src/main/qmatchers.const';
 import { StepChart } from '../../libappsop/chartsop';
import { DataHierarchy } from '../../libappsop/datahierarchy';
 import { AppMP, Demo, Scenario } from '../../libmp/appmp';
 import { startOfPlanningYear } from '../../libmp/data/data.period';
 import { dataMetalsUnits, dataMetalsUnitsProvider } from '../../libmp/data/data.unit';
 import { StepCapacityPlanning } from '../../libmp/forms/form.capacityplanning';
 import { ChartScenarioAnalysisBottleneckResources } from '../../libmp/forms/form.scenarioanalysis.bottleneckresources';
 import { StepNavigationPanel } from '../../libmp/forms/navigationpanel/form.navigationpanel';
 import { StepNavigationPanelPeriod } from '../../libmp/forms/navigationpanel/panel.period';
 
 describe('ADSO-9341 - Scenario analysis - bottleneck resources view, filtering on selection in the Navigation panel', () => {
  const appMP = AppMP.getInstance();
  const listEntity = appMP.formNavigation.listEntity;
  const panelPeriod = appMP.formNavigation.pnlPeriod;
  const viewSupplyPlanning = appMP.viewSupplyPlanning;
  const viewScenarioAnalysisBottleneckResources = appMP.viewScenarioAnalysisBottleneckResources;
  const chartBottleneck = viewScenarioAnalysisBottleneckResources.frmScenarioAnalysisBottleneckResources.chartScenarioAnalysisBottleneckResources;
  const chartTitle = ChartScenarioAnalysisBottleneckResources.chartTitle;
  const chartYAxisTitle = ChartScenarioAnalysisBottleneckResources.chartYAxisTitle;
  const gcCapacityPlanning = viewSupplyPlanning.frmCapacityPlanning.ganttChartCapacityPlanning;
  const startDateList =  [`1-Jan-${startOfPlanningYear}`,
                         `1-Feb-${startOfPlanningYear}`,
                         `1-Mar-${startOfPlanningYear}`,
                         `1-Apr-${startOfPlanningYear}`,
                         `1-May-${startOfPlanningYear}`,
                         `1-Jun-${startOfPlanningYear}`,
                         `1-Jul-${startOfPlanningYear}`,
                         `1-Aug-${startOfPlanningYear}`,
                         `1-Sep-${startOfPlanningYear}`];
  const endDateList =  [`1-Feb-${startOfPlanningYear}`,
                       `1-Mar-${startOfPlanningYear}`,
                       `1-Apr-${startOfPlanningYear}`,
                       `1-May-${startOfPlanningYear}`,
                       `1-Jun-${startOfPlanningYear}`,
                       `1-Jul-${startOfPlanningYear}`,
                       `1-Aug-${startOfPlanningYear}`,
                       `1-Sep-${startOfPlanningYear}`,
                       `1-Oct-${startOfPlanningYear}`];
  const fromDate = startDateList[0];
  const toDate = endDateList[endDateList.length - 1];
  let coldMill1Avg: string;
  let coldMill2Avg: string;
  let coldMill3Avg: string;
  let recyclingFurnaceAvg: string;
  let initialNbrOfBarChart: number;
 
  beforeAll(async () => {
    jasmine.addMatchers(qCustomMatcher);
    await appMP.login();
  });
 
  afterAll(async () => {
    await appMP.cleanupAndLogout();
  });
 
  afterEach(async () => {
    await appMP.checkToastMessage();
  });
 
  it(`Setup - ${AppMP.getDemoDataPath(Demo.Metals, Scenario.Base)}`, async () => {
    await appMP.createDemoDataset(Demo.Metals, Scenario.Base, true); // Need wait optimizer finish to have chart shows correct Utilization
  });
 
  it(`Step 1 - Open view ${viewScenarioAnalysisBottleneckResources.viewPath}`, async () => {
    await viewScenarioAnalysisBottleneckResources.switchTo();
  });
 
  it(`Step 2- ${StepNavigationPanel.openNavigationPanel()}`, async () => {
    await appMP.formNavigation.openNavigationPanel();
  });
 
  it(`Step 3 - ${StepNavigationPanel.showEntitiesList()}`, async () => {
    await appMP.formNavigation.toggleEntityList(true);
  });
 
  it(`Step 4 - ${StepChart.getXAxisLabelCount(chartTitle)}`, async () => {
    initialNbrOfBarChart = await chartBottleneck.getXAxisLabelsCount();
  });
 
  it(`Step 5 - ${StepNavigationPanel.checkUnits([dataMetalsUnits.AsiaUnit.Name])}`, async () => {
    // Given a unit name, getHierarchy will return the ancestor units recursively
    const [asia, asiaParents] = dataMetalsUnitsProvider.getHierarchy(dataMetalsUnits.AsiaUnit);
    const parentsArr = asiaParents.map((x: DataHierarchy) => x.Name);
    const asiaRow = await listEntity.getEntityRowByName(asia.Name, parentsArr);
 
    await listEntity.toggleRowCheckbox(asiaRow, true);
  });
 
  it(`Step 6 - ${StepNavigationPanel.showPeriodPanel()}`, async () => {
    await appMP.formNavigation.togglePeriod(true);
  });
 
  it(`Step 7 - ${StepNavigationPanelPeriod.setNumFuturePeriods(9)} ${StepNavigationPanelPeriod.setNumHistoricalPeriods(0)}`, async () => {
    await panelPeriod.setNumFuturePeriods('9');
    await panelPeriod.setNumHistoricalPeriods('0');
  });
 
  it(`Step 8 - Open view ${viewSupplyPlanning.viewPath}`, async () => {
    await viewSupplyPlanning.switchTo();
  });
 
  it(`Step 9 - ${StepCapacityPlanning.calcAverageCapacityPercentage([dataMetalsUnits.Coldmill1QiYing.Name], fromDate, toDate)}`, async () => {
    coldMill1Avg = await gcCapacityPlanning.getRowNodesAverageValue([dataMetalsUnits.Coldmill1QiYing.Name], startDateList, endDateList);
  });
 
  it(`Step 10 - ${StepCapacityPlanning.calcAverageCapacityPercentage([dataMetalsUnits.Coldmill2QiYing.Name], fromDate, toDate)}`, async () => {
    coldMill2Avg = await gcCapacityPlanning.getRowNodesAverageValue([dataMetalsUnits.Coldmill2QiYing.Name], startDateList, endDateList);
  });
 
  it(`Step 11 - ${StepCapacityPlanning.calcAverageCapacityPercentage([dataMetalsUnits.Coldmill3QiYing.Name], fromDate, toDate)}`, async () => {
    coldMill3Avg =  await gcCapacityPlanning.getRowNodesAverageValue([dataMetalsUnits.Coldmill3QiYing.Name], startDateList, endDateList);
  });
 
  it(`Step 12 - ${StepCapacityPlanning.calcAverageCapacityPercentage([dataMetalsUnits.RecyclingFurnaceQiYing.Name], fromDate, toDate)}`, async () => {
    recyclingFurnaceAvg = await gcCapacityPlanning.getRowNodesAverageValue([dataMetalsUnits.RecyclingFurnaceQiYing.Name], startDateList, endDateList);
  });
 
  it(`Step 13 - Open view ${viewScenarioAnalysisBottleneckResources.viewPath}`, async () => {
    await viewScenarioAnalysisBottleneckResources.switchTo();
  });
 
  it(`Step 14 - ${StepChart.verifyHasDataPoint(chartTitle, chartYAxisTitle, dataMetalsUnits.Coldmill1QiYing.Name, 'the average utilization')}`, async () => {
    await chartBottleneck.verifyHasDataPoint('', chartYAxisTitle, dataMetalsUnits.Coldmill1QiYing.Name, coldMill1Avg, 0.5);
  });
 
  it(`Step 15 - ${StepChart.verifyHasDataPoint(chartTitle, chartYAxisTitle, dataMetalsUnits.Coldmill2QiYing.Name, 'the average utilization')}`, async () => {
    await chartBottleneck.verifyHasDataPoint('', chartYAxisTitle, dataMetalsUnits.Coldmill2QiYing.Name, coldMill2Avg, 0.5);
  });
 
  it(`Step 16 - ${StepChart.verifyHasDataPoint(chartTitle, chartYAxisTitle, dataMetalsUnits.Coldmill3QiYing.Name, 'the average utilization')}`, async () => {
    await chartBottleneck.verifyHasDataPoint('', chartYAxisTitle, dataMetalsUnits.Coldmill3QiYing.Name, coldMill3Avg, 0.5);
  });
 
  it(`Step 17 - ${StepChart.verifyHasDataPoint(chartTitle, chartYAxisTitle, dataMetalsUnits.RecyclingFurnaceQiYing.Name, 'the average utilization')}`, async () => {
    await chartBottleneck.verifyHasDataPoint('', chartYAxisTitle, dataMetalsUnits.RecyclingFurnaceQiYing.Name, recyclingFurnaceAvg, 0.5);
  });
 
  it(`Step 18 - ${StepNavigationPanel.clickHomeResetToRoot()}`, async () => {
    await appMP.formNavigation.resetNaviToRoot();
  });
 
  it(`Step 19 - ${StepChart.verifyXAxisLabelCount('all bottleneck resources shown unfiltered')}`, async () => {
    // Reset filter will show all bottleneck resources across the horizon
    await chartBottleneck.verifyXAxisLabelCount(initialNbrOfBarChart);
  });
 });